static IEnumerable<string> ReplaceAppSettingOrConnectionString(XNode document, string xpath, string keyAttributeName, string keyAttributeValue, string valueAttributeName, VariableDictionary variables) { var changes = new List<string>(); var settings = ( from element in document.XPathSelectElements(xpath) let keyAttribute = element.Attribute(keyAttributeName) where keyAttribute != null where string.Equals(keyAttribute.Value, keyAttributeValue, StringComparison.InvariantCultureIgnoreCase) select element).ToList(); if (settings.Count == 0) return changes; var value = variables.Get(keyAttributeValue) ?? string.Empty; foreach (var setting in settings) { changes.Add(string.Format("Setting '{0}' = '{1}'", keyAttributeValue, value)); var valueAttribute = setting.Attribute(valueAttributeName); if (valueAttribute == null) { setting.Add(new XAttribute(valueAttributeName, value)); } else { valueAttribute.SetValue(value); } } return changes; }
private void WriteElement(XNode node, XmlWriter writer) { writer.WriteStartElement(node.Name); foreach (var attr in node.Attributes) { if (attr.Match == MatchType.Change || attr.Match == MatchType.NoMatch) writer.WriteAttributeString(attr.Name, attr.XmlNode.Value); } foreach (var text in node.Texts) { if (text.Match == MatchType.Change || text.Match == MatchType.NoMatch) writer.WriteValue(text.XmlNode.Value); } foreach (var element in node.Elements) { if (element.Match == MatchType.Change) WriteElement(element, writer); if (element.Match == MatchType.NoMatch) writer.WriteRaw(element.XmlNode.OuterXml); } writer.WriteEndElement(); }
public AdjacencyGraph<Node, Edge<Node>> CreateGraphFromXml(string xmlFilePath) { XDocument xDocument = XDocument.Load(xmlFilePath); ModelChildrenNode = xDocument.XPathSelectElement(_modelChildrenPath); var graph = CreateGraphFromNode(xDocument, ModelChildrenNode); return graph; }
static IEnumerable<XElement> SelectWithRootNamespace(XNode container, string namespaceName, IEnumerable<Traversal> traversals) { var nav = container.CreateNavigator(); var xPath = traversals.ToXPath("x"); var manager = new XmlNamespaceManager(nav.NameTable); manager.AddNamespace("x", namespaceName); return container.XPathSelectElements(xPath, manager); }
public deBSP() { this.Buffer = null; this.MapName = null; this.Header = null; this.Entities = null; this.Textures = null; }
private void LoadModules(XNode configRoot) { var elements = configRoot.XPathSelectElements("modules/module"); _moduleInstancesInstances = new List<ModuleInstance>(elements.Count()); elements.ForEachItem(m => { var type = m.Attribute("Type").Value; var active = m.Attribute("Active")?.Value.ToBoolean() ?? true; _moduleInstancesInstances.Add(new ModuleInstance(type, active)); }); }
public XElement Merge(XElement masterElement, XNode sourceElement) { var masterElementsWithIds = masterElement.XPathSelectElements("//*[@id]"); foreach (var masterElementWithId in masterElementsWithIds) { // ReSharper disable PossibleNullReferenceException var childElementWithSameId = sourceElement.XPathSelectElement("//*[@id='" + masterElementWithId.Attribute("id").Value + "']"); // ReSharper restore PossibleNullReferenceException if (childElementWithSameId != null) masterElementWithId.ReplaceWith(childElementWithSameId); } return masterElement; }
static List<string> ApplyChanges(XNode doc, VariableDictionary variables) { var changes = new List<string>(); foreach (var variable in variables.GetNames()) { changes.AddRange( ReplaceAppSettingOrConnectionString(doc, "//*[local-name()='appSettings']/*[local-name()='add']", "key", variable, "value", variables).Concat( ReplaceAppSettingOrConnectionString(doc, "//*[local-name()='connectionStrings']/*[local-name()='add']", "name", variable, "connectionString", variables).Concat( ReplaceStonglyTypeApplicationSetting(doc, "//*[local-name()='applicationSettings']//*[local-name()='setting']", "name", variable, variables)))); } return changes; }
new void SelectNode (XNode n) { MonoDevelop.Projects.Dom.DomRegion region = n.Region; XElement el = n as XElement; if (el != null && el.IsClosed && el.ClosingTag.Region.End > region.End) { region.End = el.ClosingTag.Region.End; } int s = Editor.Document.LocationToOffset (region.Start.Line, region.Start.Column ); int e = Editor.Document.LocationToOffset (region.End.Line, region.End.Column); if (e > s && s > -1) Editor.SetSelection (s, e); }
void SelectNode (XNode n) { MonoDevelop.Projects.Dom.DomRegion region = n.Region; XElement el = n as XElement; if (el != null && el.IsClosed && el.ClosingTag.Region.End > region.End) { region.End = el.ClosingTag.Region.End; } int s = Editor.GetPositionFromLineColumn (region.Start.Line, region.Start.Column); int e = Editor.GetPositionFromLineColumn (region.End.Line, region.End.Column); if (e > s && s > -1) Editor.Select (s, e); }
private static object TransformEnvironmentNewLineToParagraph(XNode node) { var element = node as XElement; if (element != null) { if (element.Name == W.p) { } return new XElement(element.Name, element.Attributes(), element.Nodes().Select(n => TransformEnvironmentNewLineToParagraph(n))); } return node; }
public static new void Parse(XNode node, DefinitionFile file) { UiView.Parse(node, file); var parser = new DefinitionParser(node); file["AutomataGrid"] = parser.ParseDelegate("AutomataGrid"); file["EditEnabled"] = parser.ParseBoolean("EditEnabled"); file["Zoom"] = parser.ParseDouble("Zoom"); file["StateToPaint"] = parser.ParseInt("StateToPaint"); file["Colors"] = parser.ParseDelegate("Colors"); file["GridColor"] = parser.ParseColor("GridColor"); }
private AdjacencyGraph<Node, Edge<Node>> CreateGraphFromNode(XDocument xDocument, XNode parent) { var graph = new AdjacencyGraph<Node, Edge<Node>>(); var nodes = xDocument.Descendants().Where(x => x.Parent != null && (x.Parent.Parent != null && (x.Parent != null && x.Parent.Parent.Parent == parent))); var fromList = nodes.Where(x => x.Parent != null && (x.Name.LocalName == "ControlFlow" && x.Parent.Name.LocalName =="FromSimpleRelationships") ); var toList = nodes.Where(x => x.Parent != null && (x.Name.LocalName == "ControlFlow" && x.Parent.Name.LocalName =="ToSimpleRelationships") ); foreach (var fromNode in fromList) { var xNode1 = fromNode.Parent.Parent; string idref = fromNode.Attribute("Idref").Value; var xNode2 = toList.Where(x => x.Parent != null && (x.Attribute("Idref").Value.ToString() == idref)) .Select(x => x.Parent.Parent).FirstOrDefault(); if (xNode1 == null || xNode2 == null) continue; Node node1 = new Node(xNode1.Attribute("Name").Value, GetNodeType(xNode1)); Node node2 = new Node(xNode2.Attribute("Name").Value, GetNodeType(xNode2)); if (!graph.Vertices.Any(x => x.Name==node1.Name && x.Type==node1.Type)) { graph.AddVertex(node1); } else { node1 = graph.Vertices.FirstOrDefault(x => x.Name == node1.Name && x.Type == node1.Type); } if (!graph.Vertices.Any(x => x.Name == node2.Name && x.Type == node2.Type)) { graph.AddVertex(node2); } else { node2 = graph.Vertices.FirstOrDefault(x => x.Name == node2.Name && x.Type == node2.Type); } var newEdge = new Edge<Node>(node1, node2); if(!graph.ContainsEdge(newEdge)) graph.AddEdge(newEdge); } return graph; }
//public static XElement XPathElement(XElement xe, string xpath) public static XElement XPathElement(XNode node, string xpath) { if (node == null) return null; object xpathResult = node.XPathEvaluate(xpath); if (xpathResult is IEnumerable) { object xpathResult2 = XPathResultGetFirstValue(xpathResult as IEnumerable); if (xpathResult2 != null) xpathResult = xpathResult2; } if (xpathResult is XElement) return (XElement)xpathResult; else return null; }
//public static string XPathValue(XElement xe, string xpath, string defaultValue = null) public static string XPathValue(XNode node, string xpath, string defaultValue = null) { if (node == null) return defaultValue; object xpathResult = node.XPathEvaluate(xpath); if (xpathResult is IEnumerable) { object xpathResult2 = XPathResultGetFirstValue(xpathResult as IEnumerable); if (xpathResult2 != null) xpathResult = xpathResult2; } string value = XPathResultGetValue(xpathResult); if (value != null) return value; else return defaultValue; }
private void LoadAppDomain(XNode configRoot) { var mde = configRoot.XPathSelectElement("appdomain"); var deleteShadowOnStartup = mde.Attribute("DeleteShadowDirectoryOnStartup")?.Value.ToBoolean() ?? true; var moduleDirectory = configRoot.XPathSelectElement("appdomain/modules")?.Attribute("Directory")?.Value ?? "ModuleInstances"; var moduleShadowCopyDirectory = configRoot.XPathSelectElement("appdomain/modules")?.Attribute("ShadowCopyDirectory")?.Value ?? @"ModuleInstances\bin"; var pluginsDirectory = configRoot.XPathSelectElement("appdomain/plugins")?.Attribute("Directory")?.Value ?? "Plugins"; var pluginsShadowCopyDirectory = configRoot.XPathSelectElement("appdomain/plugins")?.Attribute("ShadowCopyDirectory")?.Value ?? @"Plugins\bin"; AppDomainLoadData = new AppDomainLoadData(deleteShadowOnStartup, new DynamicLoadingData(pluginsDirectory, pluginsShadowCopyDirectory), new DynamicLoadingData(moduleDirectory, moduleShadowCopyDirectory)); }
/// <summary> /// Initializes a new instance of the <see cref="CSF.Zpt.DocumentProviders.ZptXmlLinqElement"/> class. /// </summary> /// <param name="node">The source XML Node.</param> /// <param name="sourceFile">Information about the element's source file.</param> /// <param name="isRoot">Whether or not this is the root element.</param> /// <param name="isImported">Whether or not this element is imported.</param> /// <param name="ownerDocument">The ZPT document which owns the element.</param> public ZptXmlLinqElement(XNode node, ISourceInfo sourceFile, IZptDocument ownerDocument, bool isRoot = false, bool isImported = false) : base(sourceFile, isRoot, isImported, ownerDocument) { if(node == null) { throw new ArgumentNullException(nameof(node)); } _node = node as XElement; if(_node.NodeType == XmlNodeType.Document) { _node = node.Document.Root; } EnforceNodeType("XML", XmlNodeType.Element, _node.NodeType); }
public bool Load(String file) { if (!System.IO.File.Exists(file)) return false; this.MapName = System.IO.Path.GetFileNameWithoutExtension(file); this.Buffer = System.IO.File.ReadAllBytes(file); this.Header = new BSP_HEADER(); this.Header.Version = System.BitConverter.ToUInt32(this.Buffer, 0); if (this.Header.Version != 30) return false; for (int i = 0; i < this.Header.Lumps.Length; i++) { this.Header.Lumps[i] = new BSP_LUMP(); this.Header.Lumps[i].Offset = System.BitConverter.ToUInt32(this.Buffer, sizeof(UInt32) + (i * 2 * sizeof(UInt32))); this.Header.Lumps[i].Size = System.BitConverter.ToUInt32(this.Buffer, sizeof(UInt32) + (i * 2 * sizeof(UInt32)) + sizeof(UInt32)); } String ES = System.Text.ASCIIEncoding.ASCII.GetString(this.Buffer, (int)this.Header.Lumps[(int)BSP_LUMP_TYPE.ENTITIES].Offset, (int)this.Header.Lumps[(int)BSP_LUMP_TYPE.ENTITIES].Size-1); this.Entities = new XNode(); ParseEntitiesString(ES, this.Entities); UInt32 NumberTextures = System.BitConverter.ToUInt32(this.Buffer, (int)this.Header.Lumps[(int)BSP_LUMP_TYPE.TEXTURES].Offset); this.Textures = new BSP_TEXTURE_HEADER[NumberTextures]; for (int i = 0; i < this.Textures.Length; i++) { this.Textures[i] = new BSP_TEXTURE_HEADER(); Int32 Offset = (int)this.Header.Lumps[(int)BSP_LUMP_TYPE.TEXTURES].Offset + System.BitConverter.ToInt32(this.Buffer, (int)this.Header.Lumps[(int)BSP_LUMP_TYPE.TEXTURES].Offset + sizeof(Int32) + (i * sizeof(UInt32))); this.Textures[i].Name = System.Text.ASCIIEncoding.ASCII.GetString(this.Buffer, Offset, 16).Split('\0')[0]; this.Textures[i].Width = System.BitConverter.ToUInt32(this.Buffer, Offset + 16); this.Textures[i].Height = System.BitConverter.ToUInt32(this.Buffer, Offset + 16 + sizeof(UInt32)); for (int j = 0; j < this.Textures[i].Offsets.Length; j++) this.Textures[i].Offsets[j] = System.BitConverter.ToUInt32(this.Buffer, Offset + 16 + sizeof(UInt32) + sizeof(UInt32) + (j * sizeof(UInt32))); } return true; }
// traverse to first child private void firstChildButton_Click( object sender, EventArgs e ) { // try to convert to an XContainer var container = current as XContainer; // if container has children, move to first child if ( container != null && container.Nodes().Any() ) { current = container.Nodes().First(); // first child // create new TreeNode for this node with correct label var newNode = new TreeNode( NodeText( current ) ); tree.Nodes.Add( newNode ); // add node to TreeNode Nodes list tree = newNode; // move current selection to newNode TreeRefresh(); // reset the tree display } // end if else { // current is not a container or has no children MessageBox.Show( "Current node has no children.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Information ); } // end else }
private static Interface10 smethod_1(XNode xnode_0) { return(smethod_0(xnode_0)); }
public static SPSymbolDef XNodeToSPSymbolDef(XNode node) { SPSymbolDef spsd = null; XElement element = null; XElement subElement = null; //XAttribute attribute = null; XNode nextNode = null; try { if (node is XElement) { element = (XElement)node; if (element.HasElements) { spsd = new SPSymbolDef(); subElement = null; if (element.FirstNode is XElement) { subElement = (XElement)element.FirstNode; } while (subElement != null) { if (subElement.Name == "DESCRIPTION") { spsd._strDescription = subElement.FirstNode.ToString(); //get element value //spsd._strDescription = spsd._strDescription.Replace("&", "&"); } if (subElement.Name.LocalName == "SYMBOLID") { spsd._strBasicSymbolId = subElement.FirstNode.ToString(); //if (spsd.BasicSymbolCode == "S*A*MFQH--*****") //{ // Console.WriteLine(""); //} } if (subElement.Name.LocalName == "MAPPING") { spsd._intMapping = int.Parse(subElement.FirstNode.ToString()); } ////////////////////////////////////////// //hopefully get rid of these 4 values soon and turn them into height & width if (subElement.Name.LocalName == "ULX") { spsd._intUpperleftX = int.Parse(subElement.FirstNode.ToString()); } if (subElement.Name.LocalName == "ULY") { spsd._intUpperleftY = int.Parse(subElement.FirstNode.ToString()); } if (subElement.Name.LocalName == "LRX") { spsd._intLowerrightX = int.Parse(subElement.FirstNode.ToString()); } if (subElement.Name.LocalName == "LRY") { spsd._intLowerrightY = int.Parse(subElement.FirstNode.ToString()); } spsd._intWidth = spsd._intLowerrightX - spsd._intUpperleftX; spsd._intHeight = spsd._intLowerrightY - spsd._intUpperleftY; ////////////////////////////// if (subElement.Name.LocalName == "WIDTH") { spsd._intWidth = int.Parse(subElement.FirstNode.ToString()); } if (subElement.Name.LocalName == "HEIGHT") { spsd._intHeight = int.Parse(subElement.FirstNode.ToString()); } nextNode = subElement.NextNode; subElement = null; while (subElement == null && nextNode != null) { if (nextNode is XElement) { subElement = (XElement)nextNode; } else { nextNode = nextNode.NextNode; } } } } } else { return(null); } } catch (System.Xml.XmlException xe) { Console.WriteLine(xe.Message); Console.WriteLine(xe.StackTrace); } catch (Exception exc) { Console.WriteLine(exc.Message); Console.WriteLine(exc.StackTrace); } if (spsd.getBasicSymbolId() != null && spsd.getBasicSymbolId() != "") { return(spsd); } else { return(null); } }
/// <summary> /// Renders the specified XNode. /// </summary> /// <param name="xNode">The <see cref="XNode">XNode</see>.</param> /// <returns></returns> public IHtmlString Markup(XNode xNode) { return(Html.C1().Markup(xNode)); }
public Compile(XNode node) : base(node) { _link = Element.Attribute("Link")?.Value; }
public DynamicXmlMetaObject(Expression expression, XNode node) : base(expression, BindingRestrictions.GetInstanceRestriction(expression, node), node) { }
public async Task PushChangeAsync(BuildManifestChange change) { await Retry.RunAsync(async attempt => { BuildManifestLocation location = change.Location; // Get the current commit. Use this throughout to ensure a clean transaction. GitReference remoteRef = await _github.GetReferenceAsync( location.GitHubProject, location.GitHubRef); string remoteCommit = remoteRef.Object.Sha; Trace.TraceInformation($"Creating update on remote commit: {remoteCommit}"); XElement remoteModelXml = await FetchModelXmlAsync( location.GitHubProject, remoteCommit, location.GitHubBasePath); OrchestratedBuildModel remoteModel = OrchestratedBuildModel.Parse(remoteModelXml); // This is a subsequent publish step: make sure a new build hasn't happened already. if (change.OrchestratedBuildId != remoteModel.Identity.BuildId) { throw new ManifestChangeOutOfDateException( change.OrchestratedBuildId, remoteModel.Identity.BuildId); } OrchestratedBuildModel modifiedModel = OrchestratedBuildModel.Parse(remoteModelXml); change.ApplyModelChanges(modifiedModel); if (modifiedModel.Identity.BuildId != change.OrchestratedBuildId) { throw new ArgumentException( "Change action shouldn't modify BuildId. Changed from " + $"'{change.OrchestratedBuildId}' to '{modifiedModel.Identity.BuildId}'.", nameof(change)); } XElement modifiedModelXml = modifiedModel.ToXml(); string[] changedSemaphorePaths = change.SemaphorePaths.ToArray(); // Check if any join groups are completed by this change. var joinCompleteCheckTasks = change.JoinSemaphoreGroups.NullAsEmpty() .Select(async g => new { Group = g, Joinable = await IsGroupJoinableAsync( location, remoteCommit, change.OrchestratedBuildId, changedSemaphorePaths, g) }); var completeJoinedSemaphores = (await Task.WhenAll(joinCompleteCheckTasks)) .Where(g => g.Joinable) .Select(g => g.Group.JoinSemaphorePath) .ToArray(); IEnumerable <SupplementaryUploadRequest> semaphoreUploads = completeJoinedSemaphores .Concat(changedSemaphorePaths) .Select(p => new SupplementaryUploadRequest { Path = p, Contents = new SemaphoreModel { BuildId = change.OrchestratedBuildId }.ToFileContent() }); IEnumerable <SupplementaryUploadRequest> uploads = semaphoreUploads.Concat(change.SupplementaryUploads.NullAsEmpty()); if (!XNode.DeepEquals(modifiedModelXml, remoteModelXml)) { uploads = uploads.Concat(new[] { new SupplementaryUploadRequest { Path = BuildManifestXmlName, Contents = modifiedModelXml.ToString() } }); } return(await PushUploadsAsync( location, change.CommitMessage, remoteCommit, uploads)); }); }
private void _printXml(XNode node) { Debug.WriteLine(node.ToString()); }
public void CreateModel(int numElementsX, int numElementsY, double jIntegralRadiusRatio) { var model = new XModel(); model.Subdomains[subdomainID] = new XSubdomain(subdomainID); this.Model = model; // Mesh generation var meshGenerator = new UniformMeshGenerator2D <XNode>(0.0, 0.0, beamLength, beamHeight, numElementsX, numElementsY); (IReadOnlyList <XNode> nodes, IReadOnlyList <CellConnectivity <XNode> > elementConnectivities) = meshGenerator.CreateMesh((id, x, y, z) => new XNode(id, x, y, z)); // Nodes foreach (XNode node in nodes) { model.Nodes.Add(node); } // Elements var factory = new XContinuumElement2DFactory(integration, jIntegration, material); var cells = new XContinuumElement2D[elementConnectivities.Count]; for (int e = 0; e < elementConnectivities.Count; ++e) { XContinuumElement2D element = factory.CreateElement(e, CellType.Quad4, elementConnectivities[e].Vertices); cells[e] = element; model.Elements.Add(element); model.Subdomains[subdomainID].Elements.Add(model.Elements[e]); } // Mesh var mesh = new BidirectionalMesh2D <XNode, XContinuumElement2D>(model.Nodes, model.Elements.Select(e => (XContinuumElement2D)e).ToArray(), beamBoundary); // Boundary conditions double tol = 1E-6; double L = DoubleCantileverBeam.beamLength; double H = DoubleCantileverBeam.beamHeight; XNode topRight = model.Nodes.Where(n => Math.Abs(n.X - L) <= tol && Math.Abs(n.Y - H) <= tol).First(); XNode bottomRight = model.Nodes.Where(n => Math.Abs(n.X - L) <= tol && Math.Abs(n.Y) <= tol).First(); topRight.Constraints.Add(new Constraint() { DOF = StructuralDof.TranslationY, Amount = +0.05 }); bottomRight.Constraints.Add(new Constraint() { DOF = StructuralDof.TranslationY, Amount = -0.05 }); foreach (XNode node in model.Nodes.Where(n => Math.Abs(n.X) <= tol)) { node.Constraints.Add(new Constraint() { DOF = StructuralDof.TranslationX, Amount = 0.0 }); node.Constraints.Add(new Constraint() { DOF = StructuralDof.TranslationY, Amount = 0.0 }); } // Create crack double elementSizeX = beamLength / numElementsX; double elementSizeY = beamHeight / numElementsY; CreateCrack(Math.Max(elementSizeX, elementSizeY), model, mesh, jIntegralRadiusRatio); }
public static void DumpNode(XNode node) { switch (node.NodeType) { case XmlNodeType.Document: XDocument document = (XDocument)node; Console.WriteLine("StartDocument"); XDeclaration declaration = document.Declaration; if (declaration != null) { Console.WriteLine("XmlDeclaration: {0} {1} {2}", declaration.Version, declaration.Encoding, declaration.Standalone); } foreach (XNode n in document.Nodes()) { DumpNode(n); } Console.WriteLine("EndDocument"); break; case XmlNodeType.Element: XElement element = (XElement)node; Console.WriteLine("StartElement: {0}", element.Name); if (element.HasAttributes) { foreach (XAttribute attribute in element.Attributes()) { Console.WriteLine("Attribute: {0} = {1}", attribute.Name, attribute.Value); } } if (!element.IsEmpty) { foreach (XNode n in element.Nodes()) { DumpNode(n); } } Console.WriteLine("EndElement: {0}", element.Name); break; case XmlNodeType.Text: XText text = (XText)node; Console.WriteLine("Text: {0}", text.Value); break; case XmlNodeType.ProcessingInstruction: XProcessingInstruction pi = (XProcessingInstruction)node; Console.WriteLine("ProcessingInstruction: {0} {1}", pi.Target, pi.Data); break; case XmlNodeType.Comment: XComment comment = (XComment)node; Console.WriteLine("Comment: {0}", comment.Value); break; case XmlNodeType.DocumentType: XDocumentType documentType = (XDocumentType)node; Console.WriteLine("DocumentType: {0} {1} {2} {3}", documentType.Name, documentType.PublicId, documentType.SystemId, documentType.InternalSubset); break; default: break; } }
internal void ClearOldLinkedCode() { Log.WriteLine("Housekeeping old Linked Code.", ConsoleColor.White, ConsoleColor.DarkGray); if (RootXelement != null) { if (StartPlaceHolder != null && EndPlaceHolder != null) { try { string oldXml = "<root>" + OldLinkedXml + "</root>"; if (oldXml.Contains("ItemGroup")) { XElement keeperElements = XElement.Parse(oldXml); // http://stackoverflow.com/a/11644640/492 foreach (XElement descendant in keeperElements.DescendantsAndSelf().Where(e => (e.Attribute("Include") ?? e.Attribute("Exclude")) != null)) { XAttribute xAttribute = descendant.Attribute("Include") ?? descendant.Attribute("Exclude"); if (xAttribute != null) { Keepers.Add(descendant); // keep stray code that is not a relative link. VS *may* have added it here. } } if (Keepers.Any()) { Log.WriteLine($"Found {Keepers.Count} potential Project Items in the Linked Zone to rescue.", ConsoleColor.Cyan); } } if (StartPlaceHolder != null && EndPlaceHolder != null && StartPlaceHolder.IsBefore(EndPlaceHolder)) { XNode startNode = StartPlaceHolder; while (startNode.NextNode != EndPlaceHolder) { startNode.NextNode.Remove(); } } foreach (XElement itemGroup in ItemGroups) { if (itemGroup.IsEmpty || (!itemGroup.Descendants().Any() && string.IsNullOrEmpty(itemGroup.Value))) { itemGroup.Remove(); } /*else if (itemGroup.IsAfter(StartPlaceHolder) && itemGroup.IsBefore(EndPlaceHolder)) * itemGroup.Remove();*/ // System.InvalidOperationException: A common ancestor is missing. } ItemGroups = RootXelement?.Elements(Settings.MSBuild + "ItemGroup").ToList(); } catch (Exception e) { App.Crash(e, $"FAILed clearing old linked code from: {DestProjAbsolutePath}"); } } Log.WriteLine("finished clearing old linked XML from source project", ConsoleColor.Gray); } }
public CommunicationBusModule() { XmlRequest = null; sqlQueryExecutor = new SqlQueryExecutor(); }
protected override VisualElement Create(XNode node) { _view = new GeocortexMobileElementsXamlView(); return(_view); }
/// <summary> /// Raises the DOMNodeRemovedFromDocument event for the specified node. /// </summary> /// <param name="node"></param> void OnNodeRemovedFromDocument(XNode node) { Contract.Requires <ArgumentNullException>(node != null); DispatchEvent(node, Events.DOMNodeRemovedFromDocument); }
/// <summary> /// Execute it in the given document with current position at the given node. /// </summary> /// <param name="dom">Document</param> /// <param name="cursor">Nodes we're currently at</param> /// <param name="stack">Execution stack</param> /// <returns>New current nodes</returns> public ICursor Exec(XNode dom, ICursor cursor, IStack stack) { return(stack.Pop()); }
public DropdownModel GetTheme() { using (var client = new System.Net.Http.HttpClient()) { var env = ConfigurationManager.AppSettings["Enviroment"]; var settings = ""; var uri = new Uri("https://api.evolutionrevolutionoflove.com/api/theme"); if (env == "Dev") { settings = ConfigurationManager.AppSettings["LocalWebApi"]; uri = new Uri("http://localhost:18760/api/theme/"); } else { settings = ConfigurationManager.AppSettings["ProductionWebApi"]; uri = new Uri("https://api.evolutionrevolutionoflove.com/api/theme"); } var response = client.GetAsync(uri).Result; var responseContent = response.Content; var responseString = responseContent.ReadAsStringAsync().Result; var x = JObject.Parse(responseString); XNode node = JsonConvert.DeserializeXNode(x.ToString(), "data"); string a = node.ToString(); string trima = a.Replace("\r\n", ""); trima = a.Replace("{", ""); trima = a.Replace("}", ""); DropdownModel model = new DropdownModel(); model.items.Add(new SelectListItem { Text = "Please Select ", Value = "0" }); XDocument xml = XDocument.Parse(trima); foreach (var el in xml.Descendants("categoryLists")) { string ID = el.Element("ID").Value; string AnimalType = el.Element("Category").Value; model.items.Add(new SelectListItem { Text = AnimalType, Value = ID }); } var animalType = ""; foreach (SelectListItem s in model.items) { if (s.Value == animalType) { s.Selected = true; } } return(model); //ViewData["animalTypeData"] = model.items; } }
public void Create3x1Model() { double elementSize = 20.0; var model = new XModel(); model.Subdomains[subdomainID] = new XSubdomain(subdomainID); this.Model = model; //Nodes model.Nodes.Add(new XNode(0, 0.0, 0.0)); model.Nodes.Add(new XNode(1, elementSize, 0.0)); model.Nodes.Add(new XNode(2, elementSize, elementSize)); model.Nodes.Add(new XNode(3, 0.0, elementSize)); model.Nodes.Add(new XNode(4, 2 * elementSize, 0.0)); model.Nodes.Add(new XNode(5, 3 * elementSize, 0.0)); model.Nodes.Add(new XNode(6, 3 * elementSize, elementSize)); model.Nodes.Add(new XNode(7, 2 * elementSize, elementSize)); // Elements XNode[][] connectivity = new XNode[3][]; connectivity[0] = new XNode[] { model.Nodes[0], model.Nodes[1], model.Nodes[2], model.Nodes[3] }; connectivity[1] = new XNode[] { model.Nodes[1], model.Nodes[4], model.Nodes[7], model.Nodes[2] }; connectivity[2] = new XNode[] { model.Nodes[4], model.Nodes[5], model.Nodes[6], model.Nodes[7] }; var factory = new XContinuumElement2DFactory(integration, jIntegration, material); var cells = new XContinuumElement2D[3]; for (int e = 0; e < 3; ++e) { XContinuumElement2D element = factory.CreateElement(e, CellType.Quad4, connectivity[e]); cells[e] = element; model.Elements.Add(element); model.Subdomains[subdomainID].Elements.Add(model.Elements[e]); } // Mesh var mesh = new BidirectionalMesh2D <XNode, XContinuumElement2D>(model.Nodes, model.Elements.Select(e => (XContinuumElement2D)e).ToArray(), beamBoundary); // Boundary conditions model.Nodes[0].Constraints.Add(new Constraint() { DOF = StructuralDof.TranslationX, Amount = 0.0 }); model.Nodes[0].Constraints.Add(new Constraint() { DOF = StructuralDof.TranslationY, Amount = 0.0 }); model.Nodes[3].Constraints.Add(new Constraint() { DOF = StructuralDof.TranslationX, Amount = 0.0 }); model.Nodes[3].Constraints.Add(new Constraint() { DOF = StructuralDof.TranslationY, Amount = 0.0 }); model.Nodes[5].Constraints.Add(new Constraint() { DOF = StructuralDof.TranslationY, Amount = -0.05 }); model.Nodes[6].Constraints.Add(new Constraint() { DOF = StructuralDof.TranslationY, Amount = +0.05 }); // Create crack CreateCrack(elementSize, model, mesh, 2.0); }
public PropertyGroup(XNode node) : base(node) { }
public ElementAtom(XNode content) { element = content as XElement; }
/// <summary> /// Converts an XNode into an XElement via XElement.Parse. /// Source pulled and modified from: /// http://codesnippets.fesslersoft.de/how-to-convert-xnode-to-xelement-in-c-and-vb-net/ /// </summary> /// <param name="xNode">The XNode to convert into an XElement.</param> /// <returns>Returns an XElement form of the current XNode.</returns> public static XElement GetXElement(this XNode xNode) { return(XElement.Parse(xNode.ToString())); }
public override double[] EvaluateFunctionsAt(XNode node) { double signedDistance = Discontinuity.SignedDistanceOf(node); return(new double[] { enrichmentFunction.EvaluateAt(signedDistance) }); }
/// <summary> /// Write out the given XML Node as Markdown. Recursive function used internally. /// </summary> /// <param name="node">The xml node to write out.</param> /// <param name="ConversionContext">The Conversion Context that will be passed around and manipulated over the course of the translation.</param> /// <returns>The converted markdown text.</returns> public static string ToMarkDown(this XNode node, ConversionContext context) { if (node is XDocument) { node = ((XDocument)node).Root; } string name; if (node.NodeType == XmlNodeType.Element) { var el = (XElement)node; name = el.Name.LocalName; if (name == "member") { string expandedName = null; if (!_MemberNamePrefixDict.TryGetValue(el.Attribute("name").Value.Substring(0, 2), out expandedName)) { expandedName = "none"; } name = expandedName.ToLowerInvariant(); } if (name == "see") { var anchor = el.Attribute("cref") != null && el.Attribute("cref").Value.StartsWith("!:#"); name = anchor ? "seeAnchor" : "seePage"; } //treat first Param element separately to add table headers. if (name.EndsWith("param") && node .ElementsBeforeSelf() .LastOrDefault() ?.Name ?.LocalName != "param") { name = "firstparam"; } try { var vals = TagRenderer.Dict[name].ValueExtractor(el, context).ToArray(); return(string.Format(TagRenderer.Dict[name].FormatString, args: vals)); } catch (KeyNotFoundException ex) { var lineInfo = (IXmlLineInfo)node; switch (context.UnexpectedTagAction) { case UnexpectedTagActionEnum.Error: throw new XmlException($@"Unknown element type ""{ name }""", ex, lineInfo.LineNumber, lineInfo.LinePosition); case UnexpectedTagActionEnum.Warn: context.WarningLogger.LogWarning($@"Unknown element type ""{ name }"" on line {lineInfo.LineNumber}, pos {lineInfo.LinePosition}"); break; case UnexpectedTagActionEnum.Accept: //do nothing; break; default: throw new InvalidOperationException($"Unexpected {nameof(UnexpectedTagActionEnum)}"); } } } if (node.NodeType == XmlNodeType.Text) { return(Regex.Replace(((XText)node).Value.Replace('\n', ' '), @"\s+", " ")); } return(""); }
/// <summary> /// Raises the DOMNodeInsertedIntoDocument event for the given node. /// </summary> /// <param name="node"></param> void OnNodeAddedToDocument(XNode node) { Contract.Requires <ArgumentNullException>(node != null); DispatchEvent(node, Events.DOMNodeInsertedIntoDocument); }
public NameUnit(XNode sender, object name) { _sender = sender; _name = name; }
public static XAttribute first_attribute(XNode element, string name) { return((element as XElement).Attributes().FirstOrDefault(x => x.Name == name)); }
private void Parse(XNode node) { if (node.NodeType == XmlNodeType.Comment) { return; } if (node is XText text) { AppendParts(_provider.CreatePart(SymbolDisplayPartKind.Text, Normalize(text.Value)).Enumerate()); return; } var element = (node as XDocument)?.Root ?? (XElement)node; var name = element.Name.LocalName; if (name == XmlNames.SummaryElement) { // TODO: does changing description effect on a line breaking? var oldDescription = currentDescription; currentDescription = SymbolDescriptionKind.Additional; foreach (var childNode in element.Nodes()) { Parse(childNode); } currentDescription = oldDescription; return; } if (name == XmlNames.ParaElement) { _lineBrokenCount = 2; foreach (var childNode in element.Nodes()) { Parse(childNode); } _lineBrokenCount = 2; return; } if (name == XmlNames.ExceptionElement) { AppendExceptionParts(element); return; } if (name == XmlNames.SeeElement || name == XmlNames.SeeAlsoElement) { foreach (var attribute in element.Attributes()) { AppendAttributeParts(name, attribute, XmlNames.CrefAttribute); } return; } if (name == XmlNames.ParameterRefElement || name == XmlNames.TypeParameterRefElement) { foreach (var attribute in element.Attributes()) { AppendAttributeParts(name, attribute, XmlNames.NameAttribute); } return; } foreach (var childNode in element.Nodes()) { Parse(childNode); } }
internal DynamicXmlReaderDmoVersion(XNode node) { _internalNode = node; }
/// <summary> /// Processes a GPX file, invoking callbacks on a <see cref="GpxVisitorBase"/> instance as /// elements are observed. /// </summary> /// <param name="reader"> /// The <see cref="XmlReader"/> to read from. /// </param> /// <param name="settings"> /// The <see cref="GpxReaderSettings"/> instance to use to control how GPX instances get /// read in, or <c>null</c> to use a general-purpose default. /// </param> /// <param name="visitor"> /// The <see cref="GpxVisitorBase"/> instance that will receive callbacks. /// </param> /// <remarks> /// This method is the "core" reading method; everything else builds off of this. /// </remarks> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="reader"/> or <paramref name="visitor"/> is /// <see langword="null"/>. /// </exception> /// <exception cref="XmlException"> /// Thrown when <paramref name="reader"/> does not specify a valid GPX file (i.e., cases /// where XSD schema validation would fail, and/or some values are <b>well</b> outside of /// the slightly stricter, but still completely reasonable, limits imposed by the idiomatic /// .NET data types above and beyond the XSD limits). /// </exception> public static void Read(XmlReader reader, GpxReaderSettings settings, GpxVisitorBase visitor) { if (reader is null) { throw new ArgumentNullException(nameof(reader)); } if (visitor is null) { throw new ArgumentNullException(nameof(visitor)); } settings = settings ?? new GpxReaderSettings(); while (reader.ReadToFollowing("gpx", Helpers.GpxNamespace)) { string version = null; string creator = settings.DefaultCreatorIfMissing; for (bool hasAttribute = reader.MoveToFirstAttribute(); hasAttribute; hasAttribute = reader.MoveToNextAttribute()) { switch (reader.Name) { case "version": version = reader.Value; break; case "creator": creator = reader.Value; break; } } if (version != "1.1" && !settings.IgnoreVersionAttribute) { throw new XmlException("'version' must be '1.1'"); } if (creator is null) { throw new XmlException("'creator' must be specified"); } if (!ReadTo(reader, XmlNodeType.Element, XmlNodeType.EndElement)) { visitor.VisitMetadata(new GpxMetadata(creator)); break; } bool expectingMetadata = true; bool expectingExtensions = true; do { if (expectingMetadata) { expectingMetadata = false; if (reader.Name == "metadata") { ReadMetadata(reader, settings, creator, visitor); if (!ReadTo(reader, XmlNodeType.Element, XmlNodeType.EndElement)) { break; } } else { visitor.VisitMetadata(new GpxMetadata(creator)); } } switch (reader.Name) { // ideally, it should all be in this order, since the XSD validation // would fail otherwise, but whatever. case "wpt": ReadWaypoint(reader, settings, visitor); break; case "rte": ReadRoute(reader, settings, visitor); break; case "trk": ReadTrack(reader, settings, visitor); break; case "extensions" when expectingExtensions: expectingExtensions = false; var extensionElement = (XElement)XNode.ReadFrom(reader); object extensions = settings.ExtensionReader.ConvertGpxExtensionElement(extensionElement.Elements()); if (!(extensions is null)) { visitor.VisitExtensions(extensions); } break; case string _ when settings.IgnoreUnexpectedChildrenOfTopLevelElement: reader.Skip(); break; default: throw new XmlException($"Unexpected xml node '{reader.Name}'"); } }while (ReadTo(reader, XmlNodeType.Element, XmlNodeType.EndElement)); } }
private DynamicXmlMetaObject(Expression expression, BindingRestrictions bindingRestrictions, XNode node) : base(expression, bindingRestrictions, node) { }
private TreeViewItemEx ProcessTreeBranch(XElement branch, XNode types, string selectedType, int selectedId, ref TreeViewItemEx selectedNode) { TreeViewItemEx returnVal = null; // Get the text, id, type and hasChildren attributes string theText = branch.GetAttribute("text"); if (isSinglePopulate) { theText = branch.GetAttribute("value"); } int theId = 0; int.TryParse(branch.GetAttribute(Common.IDAttrib), out theId); string tooltip = branch.GetAttribute("tooltip"); string theType = branch.GetAttribute(Common.Data.RowType); // Determine if the node is to have children (display a + sign) bool hasChildren = false; if (isSinglePopulate) { hasChildren = branch.HasElements; } else { hasChildren = Common.boolValue(branch.GetAttribute("hasChildren")); } // If no children, just add a single node. // If there are to be children (but none passed in the XML), create a dummy child. // Otherwise, process each child separately and add as a child to this node. if (!hasChildren) { returnVal = new TreeViewItemEx(this, theId, theType, theText, tooltip, false); } else { if (!isSinglePopulate && (branch.FirstNode == null || !(branch.FirstNode is XElement))) { returnVal = new TreeViewItemEx(this, theId, theType, theText, tooltip, false); } else { returnVal = new TreeViewItemEx(this, theId, theType, theText, tooltip, true); XElement leaf = (XElement)branch.FirstNode; while (leaf != null) { TreeViewItemEx treeBranch = ProcessTreeBranch(leaf, types, selectedType, selectedId, ref selectedNode); returnVal.Items.Add(treeBranch); ItemList.Add(treeBranch.ID, treeBranch); leaf = (XElement)leaf.NextNode; } returnVal.ChildrenFetched = true; } } // Set the selectedNode if it's a match if (theType == selectedType && theId == selectedId) { selectedNode = returnVal; } return(returnVal); }
internal override bool DeepEquals(XNode node) { XProcessingInstruction other = node as XProcessingInstruction; return other != null && target == other.target && data == other.data; }
static string valueOrEmpty( XNode node, string xpath ) { XElement element = node.XPathSelectElement( xpath ) ; return element != null ? element.Value : string.Empty ; }
/// <summary> /// Create an appropriate IAtom wrapper of the given node. /// </summary> /// <param name="node">An XElement or XText node</param> /// <returns></returns> public static IAtom MakeAtom(XNode node) { return(node.NodeType == XmlNodeType.Text ? new TextAtom(node) as IAtom : new ElementAtom(node)); }
public XNodeNavigator (XNode node, XmlNameTable nameTable) { this.node = node; this.name_table = nameTable; }
public XNodeNavigator (XNodeNavigator other) { this.node = other.node; this.attr = other.attr; this.name_table = other.name_table; }
public override bool MoveToPrevious () { if (node.PreviousNode == null) return false; node = node.PreviousNode; attr = null; return true; }
public override void MoveToRoot () { node = node.Owner; attr = null; }
public override bool MoveToParent () { if (attr != null) { attr = null; return true; } if (node.Parent == null) return false; node = node.Parent; return true; }
public override bool MoveToNext () { if (node.NextNode == null) return false; node = node.NextNode; attr = null; return true; }
public override bool MoveToFirstChild () { XContainer c = node as XContainer; if (c == null) return false; node = c.FirstNode; attr = null; return true; }
public override bool MoveTo (XPathNavigator other) { XNodeNavigator nav = other as XNodeNavigator; if (nav == null || nav.node.Owner != node.Owner) return false; node = nav.node; attr = nav.attr; return true; }
//public static IEnumerable<string> XPathValues(XElement xe, string xpath) public static IEnumerable<string> XPathValues(XNode node, string xpath) { if (node == null) return new string[0]; return XPathResultGetValues(node.XPathEvaluate(xpath)); }