public void ContainerAdd()
{
XElement element = new XElement("foo");
// Adding null does nothing.
element.Add(null);
Assert.Empty(element.Nodes());
// Add node, attrbute, string, some other value, and an IEnumerable.
XComment comment = new XComment("this is a comment");
XComment comment2 = new XComment("this is a comment 2");
XComment comment3 = new XComment("this is a comment 3");
XAttribute attribute = new XAttribute("att", "att-value");
string str = "this is a string";
int other = 7;
element.Add(comment);
element.Add(attribute);
element.Add(str);
element.Add(other);
element.Add(new XComment[] { comment2, comment3 });
Assert.Equal(
new XNode[] { comment, new XText(str + other), comment2, comment3 },
element.Nodes(),
XNode.EqualityComparer);
Assert.Equal(new[] { attribute.Name }, element.Attributes().Select(x => x.Name));
Assert.Equal(new[] { attribute.Value }, element.Attributes().Select(x => x.Value));
element.RemoveAll();
Assert.Empty(element.Nodes());
// Now test params overload.
element.Add(comment, attribute, str, other);
Assert.Equal(new XNode[] { comment, new XText(str + other) }, element.Nodes(), XNode.EqualityComparer);
Assert.Equal(new[] { attribute.Name }, element.Attributes().Select(x => x.Name));
Assert.Equal(new[] { attribute.Value }, element.Attributes().Select(x => x.Value));
// Not allowed to add a document as a child.
XDocument document = new XDocument();
Assert.Throws<ArgumentException>(() => element.Add(document));
}
/// <inheritdoc/>
protected override void HandleXmlElement(SyntaxNodeAnalysisContext context, DocumentationCommentTriviaSyntax documentation, XmlNodeSyntax syntax, XElement completeDocumentation, Location[] diagnosticLocations)
{
if (completeDocumentation != null)
{
// We are working with an <include> element
if (completeDocumentation.Nodes().OfType<XElement>().Any(element => element.Name == XmlCommentHelper.SummaryXmlTag))
{
return;
}
if (completeDocumentation.Nodes().OfType<XElement>().Any(element => element.Name == XmlCommentHelper.InheritdocXmlTag))
{
// Ignore nodes with an <inheritdoc/> tag in the included XML.
return;
}
}
else
{
if (syntax != null)
{
return;
}
if (documentation?.Content.GetFirstXmlElement(XmlCommentHelper.InheritdocXmlTag) != null)
{
// Ignore nodes with an <inheritdoc/> tag.
return;
}
}
foreach (var location in diagnosticLocations)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, location));
}
}
/// <summary>
/// Tests the Add methods on Container.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
//[Variation(Desc = "ContainerAdd")]
public void ContainerAdd()
{
XElement element = new XElement("foo");
// Adding null does nothing.
element.Add(null);
Validate.Count(element.Nodes(), 0);
// Add node, attrbute, string, some other value, and an IEnumerable.
XComment comment = new XComment("this is a comment");
XComment comment2 = new XComment("this is a comment 2");
XComment comment3 = new XComment("this is a comment 3");
XAttribute attribute = new XAttribute("att", "att-value");
string str = "this is a string";
int other = 7;
element.Add(comment);
element.Add(attribute);
element.Add(str);
element.Add(other);
element.Add(new XComment[] { comment2, comment3 });
Validate.EnumeratorDeepEquals(
element.Nodes(),
new XNode[] { comment, new XText(str + other), comment2, comment3 });
Validate.EnumeratorAttributes(element.Attributes(), new XAttribute[] { attribute });
element.RemoveAll();
Validate.Count(element.Nodes(), 0);
// Now test params overload.
element.Add(comment, attribute, str, other);
Validate.EnumeratorDeepEquals(
element.Nodes(),
new XNode[] { comment, new XText(str + other) });
Validate.EnumeratorAttributes(element.Attributes(), new XAttribute[] { attribute });
// Not allowed to add a document as a child.
XDocument document = new XDocument();
try
{
element.Add(document);
Validate.ExpectedThrow(typeof(ArgumentException));
}
catch (Exception ex)
{
Validate.Catch(ex, typeof(ArgumentException));
}
}
private IEnumerable< XNode > _ProcessIteration(XElement element, XNode iterVal,
string iterName)
{
XNode val = iterVal;
IEnumerable< XNode > results = _Env.Call( () =>
{
/* Bind the iterator symbolic name to the current value */
if ( val is XContainer )
/* Nodeset value */
{
_Env.DefineNodesetSymbol(
iterName,
( ( XContainer ) val ).
Nodes() );
}
else /* Text value */
{
_Env.DefineTextSymbol( iterName,
val.
ToString
() );
}
/* Process loop body */
return _ProcessNodes( element.Nodes() );
} );
return results;
}
/// <summary>
/// Get all available tracks from the given library
/// </summary>
private List<iTunesTrack> InitiTunesTracks()
{
XElement trackDictionary = new XElement("Tracks", from track in _itunesLibraryXDocument.Descendants("plist").Elements("dict").Elements("dict").Elements("dict")
select new XElement("track",
from key in track.Descendants("key")
select new XElement(((string)key).Replace(" ", ""), (string)(XElement)key.NextNode)));
return (trackDictionary.Nodes().Select(track => new iTunesTrack()
{
Id = ((XElement)track).Element("TrackID").ToInt(0),
Album = ((XElement)track).Element("Album").ToString(string.Empty),
Artist = ((XElement)track).Element("Artist").ToString(string.Empty),
AlbumArtist = ((XElement)track).Element("AlbumArtist").ToString(string.Empty),
BitRate = ((XElement)track).Element("BitRate").ToInt(0),
Comments = ((XElement)track).Element("Comments").ToString(string.Empty),
Composer = ((XElement)track).Element("Composer").ToString(string.Empty),
Genre = ((XElement)track).Element("Genre").ToString(string.Empty),
Kind = ((XElement)track).Element("Kind").ToString(string.Empty),
//To be able to have a + signs in the track location, we need to convert it to the correct HTML code before we use the UrlDecode
Location = WebUtility.UrlDecode(((XElement)track).Element("Location").ToString(string.Empty).Replace(Constants.URI_LOCALHOST, string.Empty).Replace("+", "%2B")).Replace('/', Path.DirectorySeparatorChar),
Name = ((XElement)track).Element("Name").ToString(string.Empty),
PlayCount = ((XElement)track).Element("PlayCount").ToInt(0),
SampleRate = ((XElement)track).Element("SampleRate").ToInt(0),
Size = ((XElement)track).Element("Size").ToInt64(0),
//Get the track time in total seconds
TotalTime = ((XElement)track).Element("TotalTime").ToInt64(0) / 1000,
TrackNumber = ((XElement)track).Element("TrackNumber").ToInt(0)
})).ToList();
}
public static void PrintChildElement(XElement parent)
{
foreach (XElement item in parent.Nodes())
{
Console.WriteLine(item.Name);
}
}
private string GetText(XElement xelement)
{
string str = string.Empty;
foreach (XNode node in xelement.Nodes())
{
string text = string.Empty;
if (node is XText)
{
text = ((XText) node).Value;
}
else if (node is XElement)
{
text = GetText((XElement) node);
}
if (!string.IsNullOrEmpty(text))
{
if (!str.EndsWith(" "))
{
str = str + " ";
}
str = str + text;
}
}
return str;
}
static bool IsSingleLineText(XElement e)
{
if (e.HasAttributes) return false;
foreach (XNode node in e.Nodes())
if (!(node is XText) || ((XText)node).Value.Contains("\n")) return false;
return true;
}
/// <summary>
/// Build an expando from an XElement
/// </summary>
/// <param name="el"></param>
/// <returns></returns>
public static ElasticObject ElasticFromXElement(XElement el)
{
var exp = new ElasticObject();
if (!string.IsNullOrEmpty(el.Value))
exp.InternalValue = el.Value;
exp.InternalName = el.Name.LocalName;
foreach (var a in el.Attributes())
exp.CreateOrGetAttribute(a.Name.LocalName, a.Value);
var textNode= el.Nodes().FirstOrDefault();
if (textNode is XText)
{
exp.InternalContent = textNode.ToString();
}
foreach (var c in el.Elements())
{
var child = ElasticFromXElement(c);
child.InternalParent = exp;
exp.AddElement(child);
}
return exp;
}
private static void AssertSerializedField(XElement docNode, string value) {
Assert.AreEqual(docNode.Nodes().Count(), 1);
var fieldNode = docNode.Element("field");
Assert.IsNotNull(fieldNode);
Assert.AreEqual("one", fieldNode.Attribute("name").Value);
Assert.AreEqual(value, fieldNode.Value);
}
/// <inheritdoc/>
protected override void HandleXmlElement(SyntaxNodeAnalysisContext context, DocumentationCommentTriviaSyntax documentation, XmlNodeSyntax syntax, XElement completeDocumentation, Location[] diagnosticLocations)
{
if (syntax == null)
{
return;
}
if (completeDocumentation != null)
{
XElement summaryNode = completeDocumentation.Nodes().OfType<XElement>().FirstOrDefault(element => element.Name == XmlCommentHelper.SummaryXmlTag);
if (summaryNode == null)
{
// Handled by SA1604
return;
}
if (!XmlCommentHelper.IsConsideredEmpty(summaryNode))
{
return;
}
}
else
{
if (!XmlCommentHelper.IsConsideredEmpty(syntax))
{
return;
}
}
foreach (var location in diagnosticLocations)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, location));
}
}
private void HandleChildCollections(XElement document, object parentObject)
{
IEnumerable<XNode> xNodes = document.Nodes();
foreach (XElement element in xNodes)
{
if (element.Attribute("ObjectType") != null)
{
if (element.Attribute("ObjectType").Value == "Collection")
{
string assemblyQualifiedClassNameCollection = element.Attribute("AssemblyQualifiedClassName").Value;
Type collectionType = Type.GetType(assemblyQualifiedClassNameCollection);
System.Collections.IList childObjectCollection = (System.Collections.IList)Activator.CreateInstance(collectionType);
IEnumerable<XNode> childNodes = element.Nodes();
foreach (XElement childElement in childNodes)
{
string assemblyQualifiedClassNameChild = childElement.Attribute("AssemblyQualifiedClassName").Value;
Type childType = Type.GetType(assemblyQualifiedClassNameChild);
object childObject = Activator.CreateInstance(childType);
YellowstonePathology.Business.Persistence.XmlPropertyWriter rootXmlPropertyWriter = new Persistence.XmlPropertyWriter(childElement, childObject);
rootXmlPropertyWriter.Write();
childObjectCollection.Add(childObject);
}
PropertyInfo collectionPropertyInfo = parentObject.GetType().GetProperty(element.Name.ToString());
collectionPropertyInfo.SetValue(parentObject, childObjectCollection, null);
}
}
}
}
static void parseEntry(XElement en, StreamWriter wr) {
foreach (var nd in en.Nodes()) {
if (nd is XElement) wr.Write(string.Format("<{0}>", LowUtils.crlfSpaces(((XElement)nd).Value)));
else if (nd is XText) wr.Write(LowUtils.crlfSpaces(((XText)nd).Value));
else throw new Exception();
}
}
/// <summary>
/// Removes all namespaces from a XDocument
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
/// <remarks>Borrowed from http://stackoverflow.com/a/7238007/41596</remarks>
public static XElement RemoveAllNamespaces(XElement e)
{
return new XElement(e.Name.LocalName,
(from n in e.Nodes()
select ((n is XElement) ? RemoveAllNamespaces(n as XElement) : n)),
(e.HasAttributes) ? (from a in e.Attributes() select a) : null);
}
/// <summary>
/// Parse the HTML node at the given element.
/// </summary>
public MarkupHtmlElement(XElement element)
{
XAttribute idAttribute = element.Attribute("id");
if (idAttribute != null && IsPublicId(idAttribute.Value))
{
Id = idAttribute.Value;
}
MarkupNode childrenNode = MarkupNode.Parse(element.Nodes());
if (childrenNode == null
|| (childrenNode is MarkupHtmlElement
&& ((MarkupHtmlElement)childrenNode).Id == null
&& ((MarkupHtmlElement)childrenNode).ChildNodes == null))
{
// This node and everything it contains is plain HTML; use it as is.
Html = element.ToString(SaveOptions.DisableFormatting);
}
else
{
// UNDONE: Optimization: Any children which are just HTML can be merged into this node.
// Extract only the top-level tag information. To do this, create a
// new element that has only the name and attributes.
XElement topElement = new XElement(element.Name,
element.Attributes()
);
Html = topElement.ToString(SaveOptions.DisableFormatting);
// Add in the children nodes.
ChildNodes =
childrenNode is MarkupElementCollection
? (MarkupElementCollection)childrenNode
: new MarkupElementCollection(new MarkupElement[] { (MarkupElement)childrenNode });
}
}
public void Collection()
{
XElement element = new XElement("Foo",
new XElement("Bar",
new XAttribute("id", "bar"),
"Control content"),
new XElement("p", "paragraph")
);
MarkupNode node = MarkupNode.Parse(element.Nodes());
Assert.IsInstanceOf<MarkupElementCollection>(node);
MarkupElementCollection collection = (MarkupElementCollection)node;
Assert.IsNotNull(collection);
Assert.AreEqual(2, collection.Count());
List<MarkupElement> items = new List<MarkupElement>(collection);
Assert.IsInstanceOf<MarkupControlInstance>(items[0]);
Assert.IsInstanceOf<MarkupHtmlElement>(items[1]);
Assert.AreEqual(
"[\n" +
" {\n" +
" control: \"Bar\",\n" +
" id: \"bar\",\n" +
" content: \"Control content\"\n" +
" },\n" +
" \"<p>paragraph</p>\"\n" +
"]",
node.JavaScript());
}
/// <summary>
/// Common logic for if/ifdef/ifndef/else constructs
/// </summary>
/// <param name="conditionalElement"></param>
/// <param name="condition"></param>
/// <returns></returns>
protected IEnumerable< XNode > _ProcessConditional(XElement conditionalElement,
bool condition)
{
return condition
? _ProcessNodes( conditionalElement.Nodes() )
: _ProcessNextElse( conditionalElement );
}
internal void ParseSectionDefinitions(XElement root, Dictionary<string, SectionSchema> sectionSchemas)
{
foreach (var node in root.Nodes())
{
var element = node as XElement;
if (element == null)
{
continue;
}
if (element.Name.LocalName == KEYWORD_SECTIONGROUP)
{
var group = SectionGroups.Add(element.Attribute(KEYWORD_SECTIONGROUP_NAME).Value);
group.Path = Name == string.Empty ? group.Name : string.Format("{0}/{1}", Path, @group.Name);
group.ParseSectionDefinitions(element, sectionSchemas);
continue;
}
if (element.Name.LocalName == KEYWORD_SECTION)
{
var sectionDefinition = Sections.Add(element.Attribute(KEYWORD_SECTION_NAME).Value);
sectionDefinition.OverrideModeDefault = element.Attribute(KEYWORD_SECTION_OVERRIDEMODEDEFAULT).LoadString(KEYWORD_OVERRIDEMODE_ALLOW);
sectionDefinition.AllowLocation = element.Attribute(KEYWORD_SECTION_ALLOWLOCATION).LoadString(KEYWORD_TRUE);
sectionDefinition.AllowDefinition = element.Attribute(KEYWORD_SECTION_ALLOWDEFINITION).LoadString(KEYWORD_SECTION_ALLOWDEFINITION_EVERYWHERE);
sectionDefinition.Path = Name == string.Empty ? sectionDefinition.Name : string.Format("{0}/{1}", Path, sectionDefinition.Name);
SectionSchema schema;
sectionSchemas.TryGetValue(sectionDefinition.Path, out schema);
sectionDefinition.Schema = schema;
}
}
}
private Expression NavigateCall(XElement node)
{
var nodes = node.Nodes().ToArray();
Expression par = ExploreNode(nodes[0] as XElement);
List<Expression> arguments = new List<Expression>();
string name = node.Attribute("method").Value;
string typename = node.Attribute("type").Value;
Type tt = null;
if (SerializationExtensions.TypeResolve != null)
tt = SerializationExtensions.TypeResolve(typename);
if (tt == null)
tt = Type.GetType(typename, true);
var mi = tt.GetMethod(name);
//Expression call = Expression.Call(par
for (int i = 1; i < nodes.Length; i++)
{
arguments.Add(ExploreNode(nodes[i] as XElement));
}
Expression result = null;
if (arguments.Count > 0)
result = Expression.Call(par, mi, arguments.ToArray());
else
result = Expression.Call(par, mi);
return result;
}
public void OnXElement2()
{
int count = 0;
_runWithEvents = (bool)Params[0];
var e = new XElement("A", new XText(""));
TestLog.Compare(e.Nodes().Any(), "Test failed:: e.Nodes().Any()");
if (_runWithEvents)
{
_eHelper = new EventsHelper(e);
count = e.Nodes().Count();
}
VerifyRemoveNodes(e);
if (_runWithEvents)
{
_eHelper.Verify(XObjectChange.Remove, count);
}
}
private void ProcessXElement(XElement xElement, StringBuilder sb, bool performReplacements)
{
performReplacements = performReplacements && IsReplacementCandidate(xElement);
AppendAsOpenTag(sb, xElement);
ProcessNodes(xElement.Nodes(), sb, performReplacements);
AppendAsCloseTag(sb, xElement);
}
public XElement (XElement other)
{
if (other == null)
throw new ArgumentNullException ("other");
name = other.name;
Add (other.Attributes ());
Add (other.Nodes ());
}
static void ChildNodeNavigation()
{
var bench = new XElement("bench",
new XElement("toolbox",
new XElement("handtool", "Hammer"),
new XElement("handtool", "Rasp")
),
new XElement("toolbox",
new XElement("handtool", "Saw"),
new XElement("powertool", "Nailgun")
),
new XComment("Be careful with the nailgun")
);
foreach (XNode node in bench.Nodes())
{
Console.WriteLine(node.ToString(SaveOptions.DisableFormatting) + ".");
}
// Retrieving elements
foreach (XElement e in bench.Elements())
{
Console.WriteLine(e.Name + "=" + e.Value);
}
foreach (var tool in bench.Elements("toolbox").Elements("handtool"))
{
Console.WriteLine("tool: {0} = {1}", tool.Name, tool.Value);
}
// query
IEnumerable<string> query =
from toolbox in bench.Elements()
where toolbox.Elements().Any(tool => tool.Value == "Nailgun")
select toolbox.Value;
PrintQueryResult(query);
query =
from toolbox in bench.Elements()
from tool in toolbox.Elements()
where tool.Name == "handtool"
select tool.Value;
PrintQueryResult(query);
// counts
int x = bench.Elements("toolbox").Count();
int y = bench.Elements().Where(e => e.Name == "toolbox").Count();
Console.WriteLine("count1: {0}, count2: {1}", x, y);
// Retrieving descendants
Console.WriteLine(bench.Descendants("handtool").Count());
foreach (XNode node in bench.DescendantNodes())
{
Console.WriteLine(node.ToString(SaveOptions.DisableFormatting));
}
}
/// <summary>
/// Reorder child nodes matching ChildNodeNames
/// </summary>
/// <param name="element">Element thats getting its children reordered</param>
private void ReorderChildNodes(XElement element)
{
List<NodeCollection> nodeCollections = new List<NodeCollection>();
var children = element.Nodes();
// This indicates if last element matched ChildNodeNames
bool inMatchingChildBlock = false;
// This value changes each time a non matching ChildNodeName is reached ensuring that only sortable elements are reordered
int childBlockIndex = 0;
NodeCollection currentNodeCollection = null;
// Run through children
foreach (var child in children)
{
if (currentNodeCollection == null)
{
currentNodeCollection = new NodeCollection();
nodeCollections.Add(currentNodeCollection);
}
if (child.NodeType == XmlNodeType.Element)
{
XElement childElement = (XElement)child;
var isMatchingChild = ChildNodeNames.Any(match => match.IsMatch(childElement.Name));
if (isMatchingChild == false || inMatchingChildBlock == false)
{
childBlockIndex++;
inMatchingChildBlock = isMatchingChild;
}
if (isMatchingChild)
{
currentNodeCollection.SortAttributeValues = SortByAttributes.Select(x => x.GetValue(childElement)).ToArray();
}
currentNodeCollection.BlockIndex = childBlockIndex;
}
currentNodeCollection.Nodes.Add(child);
if (child.NodeType == XmlNodeType.Element)
currentNodeCollection = null;
}
if (currentNodeCollection != null)
currentNodeCollection.BlockIndex = childBlockIndex + 1;
// sort node list
nodeCollections = nodeCollections.OrderBy(x => x).ToList();
// replace the element's nodes
element.ReplaceNodes(nodeCollections.SelectMany(nc => nc.Nodes));
}
public MessageHeader(XElement headerElement)
{
_name = headerElement.Name;
_content = headerElement.Nodes();
var mustUnderstandAttribute = headerElement.Attribute(Constants.Namespace + "mustUnderstand");
if (mustUnderstandAttribute!= null)
{
_mustUnderstand = XmlConvert.ToBoolean(mustUnderstandAttribute.Value);
}
}
private static void Write(XElement element, StreamWriter sw, int depth)
{
string singleindent = new string(' ', 3);
string indent = new string(' ', depth * 3);
int nodeCount = element.Nodes().Count();
sw.Write("{0}<{1}", indent, element.Name);
foreach (var attribute in element.Attributes()) { sw.Write(" {0}=\"{1}\"", attribute.Name, attribute.Value); }
if (nodeCount > 0)
{
if (nodeCount == 1 && element.Nodes().First().NodeType == XmlNodeType.Text)
{
sw.WriteLine(">{0}</{1}>", (element.Nodes().First() as XText).Value, element.Name);
}
else
{
sw.WriteLine(">");
var cdata = (element.Nodes().FirstOrDefault(n => n.NodeType == XmlNodeType.CDATA) as XCData);
if (cdata != null)
{
sw.WriteLine("{0}<![CDATA[", singleindent + indent);
foreach (var centry in cdata.Value.Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))
{
sw.WriteLine("{0}{1}", singleindent + singleindent + indent, centry);
}
sw.WriteLine("{0}]]>", singleindent + indent);
}
foreach (var child in element.Elements())
{
Write(child, sw, depth + 1);
}
sw.WriteLine("{0}</{1}>", indent, element.Name);
}
}
else
{
sw.WriteLine(" />");
}
}
public void ExecuteXElementVariation(XNode[] content, int index)
{
XElement xElem = new XElement("root", content);
XNode toRemove = xElem.Nodes().ElementAt(index);
XElement xElemOriginal = new XElement(xElem);
using (UndoManager undo = new UndoManager(xElem))
{
undo.Group();
using (EventsHelper elemHelper = new EventsHelper(xElem))
{
toRemove.Remove();
xElem.Verify();
elemHelper.Verify(XObjectChange.Remove, toRemove);
}
undo.Undo();
Assert.True(xElem.Nodes().SequenceEqual(xElemOriginal.Nodes(), XNode.EqualityComparer), "Undo did not work!");
Assert.True(xElem.Attributes().EqualsAllAttributes(xElemOriginal.Attributes(), Helpers.MyAttributeComparer), "Undo did not work!");
}
}
public static XElement FindElement(XElement parent, string child)
{
IEnumerable childnodes = parent.Nodes();
foreach (XElement item in childnodes)
{
if (item.Name.ToString().Equals(child))
break;
}
return null;
}
private NSAttributedString IterateChildNodes(XElement element, CTStringAttributes baseAttribs)
{
NSMutableAttributedString mutString = new NSMutableAttributedString ("");
foreach (var child in element.Nodes()) {
NSAttributedString formatted = NodeToAttributedString (child, baseAttribs);
if (formatted != null)
mutString.Append (formatted);
}
return mutString;
}
public bool Load (XElement XSchema)
{
SqlInsert = ProcessingInstance.GetTableDefinitionEntry (Name, "SqlInsert");
SqlDelete = ProcessingInstance.GetTableDefinitionEntry (Name, "SqlDelete");
SqlReadable = ProcessingInstance.GetTableDefinitionEntry (Name, "SqlReadable");
String KeyItemName = String.Empty;
foreach (XElement XEntityType in XSchema.Nodes ().OfType<XElement> ())
{
if (XEntityType.Name.LocalName != "EntityType")
continue;
if (XEntityType.Attribute ("Name").Value != Name)
continue;
foreach (XElement XProperty in XEntityType.Nodes ().OfType<XElement> ())
{
if (XProperty.Name.LocalName == "Key")
{
XElement XPropertyRef = XProperty.DescendantNodes ().OfType<XElement> ().First ();
if (XPropertyRef.Name.LocalName == "PropertyRef")
KeyItemName = XPropertyRef.Attribute ("Name").Value;
}
if (XProperty.Name.LocalName != "Property")
continue;
ItemDescription NewItem = new ItemDescription ();
NewItem.ProcessingInstance = ProcessingInstance;
NewItem.BackLinkTableDescription = this;
NewItem.Parent = this;
NewItem.Name = XProperty.Attribute("Name").Value;
if (NewItem.Name == KeyItemName)
NewItem.IsKey = true;
NewItem.Type = XProperty.Attribute ("Type").Value;
if (XProperty.Attribute ("Nullable") != null)
{
String Nullable = XProperty.Attribute ("Name").Value;
if (String.Compare( Nullable, "false", true) == 0)
{
NewItem.NullableProperty = false;
}
}
if (XProperty.Attribute ("MaxLength") != null)
{
String MaxLength = XProperty.Attribute ("MaxLength").Value;
NewItem.MaxLength = Convert.ToInt32 (MaxLength);
}
NewItem.ColumnDescription = ProcessingInstance.GetColumnDefinition (NewItem, Name, NewItem.Name, true);
ItemDictionary.Add (NewItem.Name, NewItem);
}
}
GetFillEntries ();
return true;
}
public bool Equals(XNode x, XNode y)
{
if (x == null)
{
return(y == null);
}
else if (y == null)
{
return(false);
}
//throw new NotImplementedException ();
if (x.NodeType != y.NodeType)
{
return(false);
}
switch (x.NodeType)
{
case XmlNodeType.Document:
XDocument doc1 = (XDocument)x;
XDocument doc2 = (XDocument)y;
if (!Equals(doc1.Declaration, doc2.Declaration))
{
return(false);
}
IEnumerator <XNode> id2 = doc2.Nodes().GetEnumerator();
foreach (XNode n in doc1.Nodes())
{
if (!id2.MoveNext())
{
return(false);
}
if (!Equals(n, id2.Current))
{
return(false);
}
}
return(!id2.MoveNext());
case XmlNodeType.Element:
XElement e1 = (XElement)x;
XElement e2 = (XElement)y;
if (e1.Name != e2.Name)
{
return(false);
}
IEnumerator <XAttribute> ia2 = e2.Attributes().GetEnumerator();
foreach (XAttribute n in e1.Attributes())
{
if (!ia2.MoveNext())
{
return(false);
}
if (!Equals(n, ia2.Current))
{
return(false);
}
}
if (ia2.MoveNext())
{
return(false);
}
IEnumerator <XNode> ie2 = e2.Nodes().GetEnumerator();
foreach (XNode n in e1.Nodes())
{
if (!ie2.MoveNext())
{
return(false);
}
if (!Equals(n, ie2.Current))
{
return(false);
}
}
return(!ie2.MoveNext());
case XmlNodeType.Comment:
XComment c1 = (XComment)x;
XComment c2 = (XComment)y;
return(c1.Value == c2.Value);
case XmlNodeType.ProcessingInstruction:
XPI p1 = (XPI)x;
XPI p2 = (XPI)y;
return(p1.Target == p2.Target && p1.Data == p2.Data);
case XmlNodeType.DocumentType:
XDocumentType d1 = (XDocumentType)x;
XDocumentType d2 = (XDocumentType)y;
return(d1.Name == d2.Name &&
d1.PublicId == d2.PublicId &&
d1.SystemId == d2.SystemId &&
d1.InternalSubset == d2.InternalSubset);
case XmlNodeType.Text:
return(((XText)x).Value == ((XText)y).Value);
}
throw new Exception("INTERNAL ERROR: should not happen");
}
public XElement(XElement other)
{
name = other.name;
Add(other.Attributes());
Add(other.Nodes());
}
/// <summary>
/// transforms XML into IQueryable of User
/// </summary>
/// <param name="twitterResponse">xml with Twitter response</param>
/// <returns>IQueryable of User</returns>
public IList ProcessResults(System.Xml.Linq.XElement twitterResponse)
{
XNamespace atom = "http://www.w3.org/2005/Atom";
XNamespace twitter = "http://api.twitter.com/";
XNamespace openSearch = "http://a9.com/-/spec/opensearch/1.1/";
var searchResult = new Search
{
ID = twitterResponse.Element(atom + "id").Value,
Title = twitterResponse.Element(atom + "title").Value,
TwitterWarning =
twitterResponse.Element(twitter + "warning") == null ?
string.Empty :
twitterResponse.Element(twitter + "warning").Value,
Updated = DateTime.Parse(twitterResponse.Element(atom + "updated").Value),
ItemsPerPage =
twitterResponse.Element(openSearch + "itemsPerPage") == null ?
-1 :
int.Parse(twitterResponse.Element(openSearch + "itemsPerPage").Value),
Language =
twitterResponse.Element(openSearch + "language") == null ?
string.Empty :
twitterResponse.Element(openSearch + "language").Value,
Alternate =
twitterResponse.Elements(atom + "link")
.Where(elem => elem.Attribute("rel").Value == "alternate").Count() == 0 ?
string.Empty :
twitterResponse.Elements(atom + "link")
.Where(elem => elem.Attribute("rel").Value == "alternate")
.First()
.Attribute("href").Value,
Self =
twitterResponse.Elements(atom + "link")
.Where(elem => elem.Attribute("rel").Value == "self").Count() == 0 ?
string.Empty :
twitterResponse.Elements(atom + "link")
.Where(elem => elem.Attribute("rel").Value == "self")
.First()
.Attribute("href").Value,
Search =
twitterResponse.Elements(atom + "link")
.Where(elem => elem.Attribute("rel").Value == "search").Count() == 0 ?
string.Empty :
twitterResponse.Elements(atom + "link")
.Where(elem => elem.Attribute("rel").Value == "search")
.First()
.Attribute("href").Value,
Refresh =
twitterResponse.Elements(atom + "link")
.Where(elem => elem.Attribute("rel").Value == "refresh").Count() == 0 ?
string.Empty :
twitterResponse.Elements(atom + "link")
.Where(elem => elem.Attribute("rel").Value == "refresh")
.First()
.Attribute("href").Value,
Entries =
(from node in twitterResponse.Nodes()
let atomEntry = node as XElement
where atomEntry != null && atomEntry.Name == atom + "entry"
let author = atomEntry.Element(atom + "author")
select new AtomEntry
{
ID = atomEntry.Element(atom + "id").Value,
Published = DateTime.Parse(atomEntry.Element(atom + "published").Value),
Title = atomEntry.Element(atom + "title").Value,
Content = atomEntry.Element(atom + "content").Value,
Updated = DateTime.Parse(atomEntry.Element(atom + "updated").Value),
Source = atomEntry.Element(twitter + "source").Value,
Language = atomEntry.Element(twitter + "lang").Value,
Alternate = atomEntry.Elements(atom + "link")
.Where(elem => elem.Attribute("rel").Value == "alternate")
.First()
.Attribute("href").Value,
Image = atomEntry.Elements(atom + "link")
.Where(elem => elem.Attribute("rel").Value == "image")
.First()
.Attribute("href").Value,
Author = new AtomAuthor
{
Name = author.Element(atom + "name").Value,
URI = author.Element(atom + "uri").Value
}
}).ToList()
};
var searchList = new List <Search>
{
searchResult
};
return(searchList);
//return searchList.AsQueryable();
}
public XElement(XElement source)
{
name = source.name;
Add(source.Attributes());
Add(source.Nodes());
}
