/// <summary> /// /// </summary> /// <param name="input">{http://microsoft.com/schemas/VisualStudio/TeamTest/2010}TestMethod</param> /// <returns></returns> public XPathNavigator GetTestTargets(XPathNavigator?input) { XNamespace ns = this.GetXmlNamespace() + ":out"; try { /* * <TestMethod codeBase="C:\Repos\mwwhited\BinaryDataDecoders\src\BinaryDataDecoders.ExpressionCalculator.Tests\bin\Debug\netcoreapp3.1\BinaryDataDecoders.ExpressionCalculator.Tests.dll" * adapterTypeName="executor://mstestadapter/v2" * className="BinaryDataDecoders.ExpressionCalculator.Tests.Parser.Int64ExpressionParserTests" * name="GetDistinctVariablesTests" /> */ var codeBase = input?.GetAttribute("codeBase", ""); var className = input?.GetAttribute("className", ""); var name = input?.GetAttribute("name", ""); if (!File.Exists(codeBase)) { return(new XElement(ns + "targets", new XComment($"File: \"{codeBase}\" not found")).ToXPathNavigable().CreateNavigator()); } var assembly = string.IsNullOrWhiteSpace(codeBase) ? null : Assembly.LoadFrom(codeBase); var testClass = string.IsNullOrWhiteSpace(className) ? null : assembly?.GetType(className); var testMethod = string.IsNullOrWhiteSpace(name) ? null : testClass?.GetMethod(name); var attributes = testMethod?.GetCustomAttributes <TestTargetAttribute>() ?? Enumerable.Empty <TestTargetAttribute>(); var xml = new XElement(ns + "targets", from a in attributes select new XElement(ns + "target", new XAttribute("name", a.Class.Name), new XAttribute("namespace", a.Class.Namespace), new XAttribute("assembly", a.Class.Assembly.FullName), (string.IsNullOrWhiteSpace(a.Member) ? null : new XAttribute("member", a.Member)) ) ); var xPathNavigable = xml.ToXPathNavigable(); var xPathNavigator = xPathNavigable.CreateNavigator(); return(xPathNavigator); } catch (Exception ex) { return(new XElement(ns + "targets", new XComment(ex.Message)).ToXPathNavigable().CreateNavigator()); } }
Coverage CoverageFromSummaryNode(XPathNavigator summaryNode) { var hasSequencePoints = double.TryParse(summaryNode?.GetAttribute("numSequencePoints", ""), out var sequencePoints); var hasVisitedSequencePoints = double.TryParse(summaryNode?.GetAttribute("visitedSequencePoints", ""), out var visitedSequencePoints); var hasBranchPoints = double.TryParse(summaryNode?.GetAttribute("numBranchPoints", ""), out var branchPoints); var hasVisitedBranchPoints = double.TryParse(summaryNode?.GetAttribute("visitedBranchPoints", ""), out var visitedBranchPoints); if (summaryNode == null || !hasSequencePoints || !hasVisitedSequencePoints || !hasBranchPoints || !hasVisitedBranchPoints) { return(Coverage.NaN); } var lineCoverage = (visitedSequencePoints / sequencePoints) * 100; var branchCoverage = (visitedBranchPoints / branchPoints) * 100; return(new Coverage(lineCoverage, branchCoverage)); }
public MediaValues(XPathNavigator xpath) { if (xpath == null) throw new ArgumentNullException("xpath"); Name = xpath.GetAttribute("nodeName", ""); Values = new Dictionary<string, string>(); var result = xpath.SelectChildren(XPathNodeType.Element); while (result.MoveNext()) { if (result.Current != null && !result.Current.HasAttributes) { Values.Add(result.Current.Name, result.Current.Value); } } if (Values.Keys.Contains("error")) { NiceUrl = ""; } else { NiceUrl = Values["umbracoFile"]; } }
//===================================================================== /// <inheritdoc /> public override void Initialize(XPathNavigator configuration) { XPathNavigator syntaxNode = configuration.SelectSingleNode("syntax"); string syntaxInputXPath = syntaxNode.GetAttribute("input", String.Empty); if (String.IsNullOrEmpty(syntaxInputXPath)) { throw new ConfigurationErrorsException("You must specify an XPath for input in the syntax element"); } syntaxInput = XPathExpression.Compile(syntaxInputXPath); string syntaxOutputXPath = syntaxNode.GetAttribute("output", String.Empty); if (String.IsNullOrEmpty(syntaxOutputXPath)) { throw new ConfigurationErrorsException("You must specify an XPath for output in the syntax element"); } syntaxOutput = XPathExpression.Compile(syntaxOutputXPath); string attrValue = syntaxNode.GetAttribute("renderReferenceLinks", String.Empty); if (String.IsNullOrWhiteSpace(attrValue) || !Boolean.TryParse(attrValue, out renderReferenceLinks)) { renderReferenceLinks = false; } XPathNodeIterator generatorNodes = configuration.Select("generators/generator"); // Configuration changes are stored separately since the actual generators may be added to the // configuration file at build time. Substitution of the edited configuration is easier to do here. var generatorConfigs = configuration.SelectSingleNode("configurations"); // If we have configuration nodes, note the order of the syntax generators. These will be used to // order the snippets. if (generatorConfigs != null) { int order = 1; foreach (XPathNavigator id in generatorConfigs.Select("generator/@id")) { languageOrder.Add(id.Value, order++); } } foreach (XPathNavigator generatorNode in generatorNodes) { // Get the ID of the syntax generator string id = generatorNode.GetAttribute("id", String.Empty); if (String.IsNullOrWhiteSpace(id)) { this.WriteMessage(MessageLevel.Error, "Each generator element must have an id attribute"); } var generatorFactory = generatorFactories.FirstOrDefault(g => g.Metadata.Id == id); if (generatorFactory == null) { this.WriteMessage(MessageLevel.Error, "A syntax generator with the ID '{0}' could not be found", id); } // Track the languages for grouping generatorLanguages.Add(generatorFactory.Metadata.Id); languageSet.Add(generatorFactory.Metadata); foreach (string alternateId in (generatorFactory.Metadata.AlternateIds ?? String.Empty).Split( new[] { ',', ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries)) { generatorLanguages.Add(alternateId); } try { var generator = generatorFactory.Value.Create(); var configNode = generatorNode.Clone(); if (generatorConfigs != null) { var alternateConfig = generatorConfigs.SelectSingleNode("generator[@id='" + id + "']"); if (alternateConfig != null && alternateConfig.HasChildren) { // Since there may be custom attributes on the generator node, we'll make a copy and // substitute the child elements that make up the configuration. var alternate = XElement.Parse(alternateConfig.OuterXml); var genNode = XElement.Parse(configNode.OuterXml); genNode.RemoveNodes(); genNode.Add(alternate.Elements()); configNode = genNode.CreateNavigator(); } } generator.Initialize(configNode); generators.Add(generator); } catch (Exception ex) { this.WriteMessage(MessageLevel.Error, "An error occurred while attempting to instantiate " + "the '{0}' syntax generator. The error message is: {1}{2}", id, ex.Message, ex.InnerException != null ? "\r\n" + ex.InnerException.Message : String.Empty); } } this.WriteMessage(MessageLevel.Info, "Loaded {0} syntax generators.", generators.Count); // If this is not found or set, we'll assume the presentation style does not support grouping var containerElement = configuration.SelectSingleNode("containerElement"); if (containerElement != null) { // If grouping is disabled, skip the remainder of the set up. This will happen if the user adds // a custom configuration to a project for a presentation style that doesn't support it. bool groupingEnabled; containerElementName = containerElement.GetAttribute("name", String.Empty); attrValue = containerElement.GetAttribute("groupingEnabled", String.Empty); if (String.IsNullOrWhiteSpace(attrValue) || !Boolean.TryParse(attrValue, out groupingEnabled)) { groupingEnabled = false; } if (!groupingEnabled || String.IsNullOrWhiteSpace(containerElementName)) { return; } // Get the "no example tab" options attrValue = containerElement.GetAttribute("addNoExampleTabs", String.Empty); if (String.IsNullOrWhiteSpace(attrValue) || !Boolean.TryParse(attrValue, out addNoExampleTabs)) { addNoExampleTabs = true; } attrValue = containerElement.GetAttribute("includeOnSingleSnippets", String.Empty); if (String.IsNullOrWhiteSpace(attrValue) || !Boolean.TryParse(attrValue, out includeOnSingleSnippets)) { includeOnSingleSnippets = false; } // Create the XPath queries used for code snippet grouping and sorting var context = new CustomContext(); context.AddNamespace("ddue", "http://ddue.schemas.microsoft.com/authoring/2003/5"); referenceRoot = XPathExpression.Compile("document/comments|document/syntax"); referenceCode = XPathExpression.Compile("//code|//div[@codeLanguage]"); conceptualRoot = XPathExpression.Compile("document/topic"); conceptualCode = XPathExpression.Compile("//ddue:code|//ddue:snippet"); conceptualCode.SetContext(context); // Hook up the event handler to group and sort code snippets just prior to XSL transformation this.BuildAssembler.ComponentEvent += TransformComponent_TopicTransforming; } }
//===================================================================== /// <summary> /// This is used to create the index cache database /// </summary> /// <param name="configuration">The configuration to use</param> private PersistentDictionary <string, string> CreateCache(XPathNavigator configuration) { PersistentDictionary <string, string> cache = null; HashSet <string> namespaceFileFilter = new HashSet <string>(); string groupId, cachePathAttrName, cachePath, baseDirectory, wildcardPath, recurseValue, dupWarning, fullPath, directoryPart, filePart; bool recurse, reportDuplicateIds, isProjectData = false; int localCacheSize, filesToLoad; var parent = configuration.Clone(); parent.MoveToParent(); groupId = configuration.GetAttribute("groupId", String.Empty); // If caching project data, they will all go into a common index if (groupId.StartsWith("Project_", StringComparison.OrdinalIgnoreCase)) { cachePathAttrName = "projectCachePath"; isProjectData = true; } else { cachePathAttrName = "frameworkCachePath"; } cache = esentCaches.FirstOrDefault(c => c.Database.Contains(groupId)); if (cache != null) { cachePath = cache.Database; } else { cachePath = parent.GetAttribute(cachePathAttrName, String.Empty); if (String.IsNullOrWhiteSpace(cachePath)) { return(null); } cachePath = Path.Combine(cachePath, groupId); string cacheSize = parent.GetAttribute("localCacheSize", String.Empty); if (String.IsNullOrWhiteSpace(cacheSize) || !Int32.TryParse(cacheSize, out localCacheSize)) { localCacheSize = 2500; } // Column compression is left on here as it does benefit the string data cache = new PersistentDictionary <string, string>(cachePath) { LocalCacheSize = localCacheSize }; } baseDirectory = configuration.GetAttribute("base", String.Empty); if (!String.IsNullOrWhiteSpace(baseDirectory)) { baseDirectory = Environment.ExpandEnvironmentVariables(baseDirectory); } wildcardPath = configuration.GetAttribute("files", String.Empty); if (String.IsNullOrWhiteSpace(wildcardPath)) { base.Component.WriteMessage(MessageLevel.Error, "Each data element must have a files attribute " + "specifying which files to index."); } wildcardPath = Environment.ExpandEnvironmentVariables(wildcardPath); recurseValue = configuration.GetAttribute("recurse", String.Empty); if (String.IsNullOrWhiteSpace(recurseValue) || !Boolean.TryParse(recurseValue, out recurse)) { recurse = false; } // Support suppression of duplicate ID warnings. This can happen a lot when common classes appear in // multiple assemblies. dupWarning = configuration.GetAttribute("duplicateWarning", String.Empty); if (String.IsNullOrWhiteSpace(dupWarning) || !Boolean.TryParse(dupWarning, out reportDuplicateIds)) { reportDuplicateIds = true; } if (String.IsNullOrEmpty(baseDirectory)) { fullPath = wildcardPath; } else { // Verify that the directory exists if (!Directory.Exists(baseDirectory)) { throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, "The targets " + "directory '{0}' does not exist. The configuration is most likely out of date. " + "Please delete this component from the project, add it back, and reconfigure it.", baseDirectory), "configuration"); } fullPath = Path.Combine(baseDirectory, wildcardPath); } fullPath = Environment.ExpandEnvironmentVariables(fullPath); directoryPart = Path.GetDirectoryName(fullPath); if (String.IsNullOrEmpty(directoryPart)) { directoryPart = Environment.CurrentDirectory; } filePart = Path.GetFileName(fullPath); // Filtering reduces the number of files to load, especially for the core reflection data files namespaceFileFilter.Clear(); foreach (XPathNavigator filter in configuration.Select("namespace/@file")) { namespaceFileFilter.Add(filter.Value); } // Loading new targets can take a while so issue a diagnostic message as an alert filesToLoad = 0; if (namespaceFileFilter.Count != 0) { // Reflection data can be filtered by namespace so some or all of it may already be there foreach (string file in Directory.EnumerateFiles(directoryPart, filePart, recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)) { if ((namespaceFileFilter.Count == 0 || namespaceFileFilter.Contains(Path.GetFileName(file))) && !cache.ContainsKey("N:" + Path.GetFileNameWithoutExtension(file))) { filesToLoad++; } } } else { // Comments files can't be filtered by namespace so we'll assume that if the collection is not // empty, it has already been loaded unless it's a project comments file list. In that case, // we will merge them if necessary. if (isProjectData || cache.Count == 0) { filesToLoad = Directory.EnumerateFiles(directoryPart, filePart, recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly).Count(); } } if (filesToLoad != 0) { // The time estimate is a ballpark figure and depends on the system base.Component.WriteMessage(MessageLevel.Diagnostic, "{0} file(s) need to be added to the " + "ESENT index cache database. Indexing them will take about {1:N0} minute(s), please be " + "patient. Cache location: {2}", filesToLoad, Math.Ceiling(filesToLoad / 60.0), cachePath); // Limit the degree of parallelism or it overwhelms the ESENT version store Parallel.ForEach(Directory.EnumerateFiles(directoryPart, filePart, recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly), new ParallelOptions { MaxDegreeOfParallelism = 3 }, file => { // Skip the file if not in a defined filter if (namespaceFileFilter.Count != 0 && !namespaceFileFilter.Contains(Path.GetFileName(file))) { return; } // Get the keys from the file and add them to the index foreach (var kv in base.GetValues(file)) { // Only report the warning if wanted if (cache.ContainsKey(kv.Key) && reportDuplicateIds) { this.Component.WriteMessage(MessageLevel.Warn, "An entry for the key '{0}' " + "already exists and will be replaced by the one from '{1}'", kv.Key, file); } cache[kv.Key] = kv.Value.InnerXml; } }); } return(cache); }
protected virtual void ProcessArguments(ControllerConfiguration config, ActionArgs args) { if (args.Values == null) { return; } FieldValueDictionary values = new FieldValueDictionary(args); _pk = null; // detect negative primary keys XPathNavigator pkNav = config.SelectSingleNode("/c:dataController/c:fields/c:field[@isPrimaryKey=\'true\']"); if (pkNav != null) { FieldValue fv = null; if (values.TryGetValue(pkNav.GetAttribute("name", String.Empty), out fv)) { int value = 0; if ((fv.NewValue != null) && int.TryParse(Convert.ToString(fv.NewValue), out value)) { if (value < 0) { if (args.CommandName == "Insert") { // request a new row from business rules PageRequest newRowRequest = new PageRequest(); newRowRequest.Controller = args.Controller; newRowRequest.View = args.View; newRowRequest.Inserting = true; newRowRequest.RequiresMetaData = true; newRowRequest.MetadataFilter = new string[] { "fields" }; ViewPage page = ControllerFactory.CreateDataController().GetPage(newRowRequest.Controller, newRowRequest.View, newRowRequest); if (page.NewRow != null) { for (int i = 0; (i < page.NewRow.Length); i++) { object newValue = page.NewRow[i]; if (newValue != null) { DataField field = page.Fields[i]; if (field.IsPrimaryKey) { // resolve the value of the primary key ResolvePrimaryKey(args.Controller, fv.Name, value, newValue); value = 0; fv.NewValue = newValue; } else { // inject a missing default value in the arguments FieldValue newFieldValue = null; if (values.TryGetValue(field.Name, out newFieldValue)) { if (!(newFieldValue.Modified)) { newFieldValue.NewValue = newValue; newFieldValue.Modified = true; } } else { List <FieldValue> newValues = new List <FieldValue>(args.Values); newFieldValue = new FieldValue(field.Name, newValue); newValues.Add(newFieldValue); args.Values = newValues.ToArray(); values[field.Name] = newFieldValue; } } } } } } // resolve the primary key after the command execution if (value < 0) { _pk = new FieldValue(fv.Name, value); fv.NewValue = null; fv.Modified = false; } } } } } // resolve negative foreign keys if (_resolvedKeys.Count > 0) { XPathNodeIterator fkIterator = config.Select("/c:dataController/c:fields/c:field[c:items/@dataController]"); while (fkIterator.MoveNext()) { FieldValue fv = null; if (values.TryGetValue(fkIterator.Current.GetAttribute("name", String.Empty), out fv)) { XPathNavigator itemsDataControllerNav = fkIterator.Current.SelectSingleNode("c:items/@dataController", config.Resolver); object resolvedKey = null; if (_resolvedKeys.TryGetValue(String.Format("{0}${1}", itemsDataControllerNav.Value, fv.NewValue), out resolvedKey)) { fv.NewValue = resolvedKey; } } } } }
// References private void WriteTypeReference(XPathNavigator reference, SyntaxWriter writer) { switch (reference.LocalName) { case "arrayOf": int rank = Convert.ToInt32(reference.GetAttribute("rank", String.Empty), CultureInfo.InvariantCulture); XPathNavigator element = reference.SelectSingleNode(typeExpression); WriteTypeReference(element, writer); writer.WriteString("["); for (int i = 1; i < rank; i++) { writer.WriteString(","); } writer.WriteString("]"); break; case "pointerTo": XPathNavigator pointee = reference.SelectSingleNode(typeExpression); WriteTypeReference(pointee, writer); writer.WriteString("*"); break; case "referenceTo": XPathNavigator referee = reference.SelectSingleNode(typeExpression); WriteTypeReference(referee, writer); break; case "type": string id = reference.GetAttribute("api", String.Empty); XPathNavigator outerTypeReference = reference.SelectSingleNode(typeOuterTypeExpression); if (outerTypeReference != null) { WriteTypeReference(outerTypeReference, writer); writer.WriteString("."); } WriteNormalTypeReference(id, writer); XPathNodeIterator typeModifiers = reference.Select(typeModifiersExpression); while (typeModifiers.MoveNext()) { WriteTypeReference(typeModifiers.Current, writer); } break; case "template": string name = reference.GetAttribute("name", String.Empty); writer.WriteString(name); XPathNodeIterator modifiers = reference.Select(typeModifiersExpression); while (modifiers.MoveNext()) { WriteTypeReference(modifiers.Current, writer); } break; case "specialization": writer.WriteString("<"); XPathNodeIterator arguments = reference.Select(specializationArgumentsExpression); while (arguments.MoveNext()) { if (arguments.CurrentPosition > 1) { writer.WriteString(", "); } WriteTypeReference(arguments.Current, writer); } writer.WriteString(">"); break; } }
/// <inheritdoc /> public override void Initialize(XPathNavigator configuration) { XPathNavigator keywordsNode = configuration.SelectSingleNode("keywords"); if (keywordsNode == null) { return; } string filespec = keywordsNode.GetAttribute("files", String.Empty); filespec = Environment.ExpandEnvironmentVariables(filespec); string keywordXPath = keywordsNode.GetAttribute("keyword", String.Empty); string topicXPath = keywordsNode.GetAttribute("topic", String.Empty); if (String.IsNullOrEmpty(keywordXPath) || String.IsNullOrEmpty(topicXPath) || String.IsNullOrEmpty(filespec)) { return; } xpathFromConfig = keywordXPath; string[] keywordFiles = null; if (File.Exists(filespec)) { // we're loading a single file AddBKeywords(filespec, topicXPath, keywordXPath); } else { // must be loading a set of files if (Directory.Exists(filespec)) { // if they specified a directory, transform all the files in the directory keywordFiles = Directory.GetFiles(filespec); } else { // it's not a file or a directory, maybe it's a path with wildcards string directoryPath = Path.GetDirectoryName(filespec); string filePath = Path.GetFileName(filespec); keywordFiles = Directory.GetFiles(directoryPath, filePath); } foreach (string file in keywordFiles) { // load targets from each file AddBKeywords(file, topicXPath, keywordXPath); } } // set up the context // put in a default entry for ddue nsManager.AddNamespace("ddue", "http://ddue.schemas.microsoft.com/authoring/2003/6"); // look for context nodes, which could override the default XPathNodeIterator contextNodes = configuration.Select("context"); foreach (XPathNavigator contextNode in contextNodes) { string prefix = contextNode.GetAttribute("prefix", String.Empty); string uri = contextNode.GetAttribute("name", String.Empty); nsManager.AddNamespace(prefix, uri); } // set up the index of source files XPathNodeIterator sourceNodes = configuration.Select("source"); foreach (XPathNavigator sourceNode in sourceNodes) { string valueXPath = sourceNode.GetAttribute("value", String.Empty); string keyXPath = sourceNode.GetAttribute("key", String.Empty); if (String.IsNullOrEmpty(valueXPath) || String.IsNullOrEmpty(keyXPath)) { WriteMessage(MessageLevel.Error, "@key and @value must be set in the 'source' node."); return; } keyQuery = XPathExpression.Compile(keyXPath); valueQuery = XPathExpression.Compile(valueXPath); // search the data directories for entries XPathNodeIterator dataNodes = sourceNode.Select("data"); foreach (XPathNavigator dataNode in dataNodes) { string dataFiles = dataNode.GetAttribute("files", String.Empty); dataFiles = Environment.ExpandEnvironmentVariables(dataFiles); if ((dataFiles == null) || (dataFiles.Length == 0)) { throw new ConfigurationErrorsException("When instantiating a CopyFromDirectory component, you must specify a directory path using the files attribute."); } WriteMessage(MessageLevel.Info, "Searching for files that match '{0}'.", dataFiles); int fileCount = ParseDocuments(dataFiles); WriteMessage(MessageLevel.Info, "Found {0} files.", fileCount); } WriteMessage(MessageLevel.Info, "Indexed {0} elements.", index.Count); } // get the copy commands XPathNodeIterator copyNodes = configuration.Select("copy"); foreach (XPathNavigator copyNode in copyNodes) { string sourceXPath = copyNode.GetAttribute("source", String.Empty); string targetXPath = copyNode.GetAttribute("target", String.Empty); if (String.IsNullOrEmpty(sourceXPath) || String.IsNullOrEmpty(targetXPath)) { WriteMessage(MessageLevel.Error, "@source and @target must be set in the 'copy' node."); return; } copySets.Add(new CopySet(sourceXPath, targetXPath, nsManager)); } }
public Action(XPathNavigator action, IXmlNamespaceResolver resolver) { this._id = action.GetAttribute("id", String.Empty); this._commandName = action.GetAttribute("commandName", String.Empty); this._commandArgument = action.GetAttribute("commandArgument", String.Empty); this._headerText = action.GetAttribute("headerText", String.Empty); this._description = action.GetAttribute("description", String.Empty); this._cssClass = action.GetAttribute("cssClass", String.Empty); this._confirmation = action.GetAttribute("confirmation", String.Empty); this._notify = action.GetAttribute("notify", String.Empty); this._whenLastCommandName = action.GetAttribute("whenLastCommandName", String.Empty); this._whenLastCommandArgument = action.GetAttribute("whenLastCommandArgument", String.Empty); this._causesValidation = !((action.GetAttribute("causesValidation", String.Empty) == "false")); this._whenKeySelected = (action.GetAttribute("whenKeySelected", String.Empty) == "true"); this._whenTag = action.GetAttribute("whenTag", String.Empty); this._whenHRef = action.GetAttribute("whenHRef", String.Empty); this._whenView = action.GetAttribute("whenView", String.Empty); this._whenClientScript = action.GetAttribute("whenClientScript", String.Empty); this._key = action.GetAttribute("key", String.Empty); }
private void ObjectElementUsageForClassStruct(XPathNavigator reflection, SyntaxWriter writer) { string typeName = (string)reflection.Evaluate(apiNameExpression); bool isGeneric = (bool)reflection.Evaluate(apiIsGenericExpression); string xamlBlockId = System.Enum.GetName(typeof(XamlHeadingID), XamlHeadingID.xamlObjectElementUsageHeading); string contentPropertyId = (string)reflection.Evaluate(contentPropertyIdExpression); if (String.IsNullOrEmpty(contentPropertyId)) { contentPropertyId = (string)reflection.Evaluate(ancestorContentPropertyIdExpression); } // start the syntax block writer.WriteStartSubBlock(xamlBlockId); writer.WriteString("<"); if (isGeneric) { writer.WriteIdentifier(typeName); // for generic types show the type arguments XPathNodeIterator templates = (XPathNodeIterator)reflection.Evaluate(apiTemplatesExpression); if (templates.Count > 0) { writer.WriteString(" x:TypeArguments=\""); while (templates.MoveNext()) { XPathNavigator template = templates.Current; string name = template.GetAttribute("name", String.Empty); writer.WriteString(name); if (templates.CurrentPosition < templates.Count) { writer.WriteString(","); } } writer.WriteString("\""); } } else { // for non-generic types just show the name writer.WriteIdentifier(typeName); } if (String.IsNullOrEmpty(contentPropertyId)) { writer.WriteString(" .../>"); } else { // close the start tag writer.WriteString(">"); // the inner xml of the Object Element syntax for a type with a content property // is a link to the content property writer.WriteLine(); writer.WriteString(" "); writer.WriteReferenceLink(contentPropertyId); writer.WriteLine(); // write the end tag writer.WriteString("</"); writer.WriteIdentifier(typeName); writer.WriteString(">"); } // end the sub block writer.WriteEndSubBlock(); }
private static HashSet <string> ParsePluginsXML(string platform, List <string> in_pluginFiles) { HashSet <string> newDlls = new HashSet <string>(); foreach (string pluginFile in in_pluginFiles) { if (!File.Exists(pluginFile)) { continue; } try { XmlDocument doc = new XmlDocument(); doc.Load(pluginFile); XPathNavigator Navigator = doc.CreateNavigator(); XPathNavigator pluginInfoNode = Navigator.SelectSingleNode("//PluginInfo"); string boolMotion = pluginInfoNode.GetAttribute("Motion", ""); XPathNodeIterator it = Navigator.Select("//Plugin"); if (boolMotion == "true") { newDlls.Add("AkMotion"); } foreach (XPathNavigator node in it) { uint pid = UInt32.Parse(node.GetAttribute("ID", "")); if (pid == 0) { continue; } string dll = string.Empty; if (platform == "Switch") { if ((PluginID)pid == PluginID.WwiseMeter) { dll = "AkMeter"; } } else if (builtInPluginIDs.Contains((PluginID)pid)) { continue; } if (string.IsNullOrEmpty(dll)) { dll = node.GetAttribute("DLL", ""); } newDlls.Add(dll); } } catch (Exception ex) { Debug.LogError("Wwise: " + pluginFile + " could not be parsed. " + ex.Message); } } return(newDlls); }
private static string[] WriteTableNames(string xmlId, string def) { Trace.WriteLine("auto referenceAddress;"); string ecuid = null; string memmodel = null; int tableCount = 0; string datatype = null; bool ecu16bit = false; int dtaddr = 0; string cpu = "32"; string rombase = GetRomBase(xmlId, def); string[] roms = new string[2] { rombase, xmlId }; using (Stream stream = File.OpenRead(def)) { XPathDocument doc = new XPathDocument(stream); XPathNavigator nav = doc.CreateNavigator(); foreach (string id in roms) { tableCount = 0; names.Clear(); if (id.Contains("BASE")) { continue; } else if (id.Equals(rombase)) { Trace.WriteLine("Warning(\"Marking tables using addresses from inherited base ROM: " + id.ToUpper() + "\");"); } string path = "/roms/rom/romid[xmlid='" + id + "']"; XPathNodeIterator iter = nav.Select(path); iter.MoveNext(); nav = iter.Current; nav.MoveToChild(XPathNodeType.Element); while (nav.MoveToNext()) { if (nav.Name == "ecuid") { ecuid = nav.InnerXml; } if (nav.Name == "memmodel") { memmodel = nav.InnerXml; break; } } if (string.IsNullOrEmpty(ecuid)) { Trace.TraceWarning("Could not find definition for " + id); return(null); } if (memmodel.Contains("68HC")) { ecu16bit = true; cpu = "16"; } nav.MoveToParent(); while (nav.MoveToNext()) { if (nav.Name == "table") { string name = nav.GetAttribute("name", ""); string storageAddress = nav.GetAttribute("storageaddress", ""); name = ConvertName(name); UpdateTableList(name, storageAddress); if (ecu16bit) { datatype = ConvertName("Table_" + name); dtaddr = Convert.ToInt32(storageAddress, 16); dtaddr = dtaddr - 1; } List <string> axes = new List <string>(); if (nav.HasChildren) { nav.MoveToChild(XPathNodeType.Element); do { string axis = nav.GetAttribute("type", ""); axes.Add(axis); string axisAddress = nav.GetAttribute("storageaddress", ""); axis = ConvertName(name + "_" + axis); UpdateTableList(axis, axisAddress); } while (nav.MoveToNext()); if (axes.Count == 2 && (axes[0].ToUpper() == "X AXIS" && axes[1].ToUpper() == "Y AXIS") && !ecu16bit) { string tableName = ConvertName("Table_" + name); UpdateTableList(tableName, "2axis"); } else if (axes.Count == 1 && axes[0].ToUpper() == "Y AXIS" && !ecu16bit) { string tableName = ConvertName("Table_" + name); UpdateTableList(tableName, "1axis"); } else if (axes.Count > 0 && ecu16bit && axes[0].ToUpper().Contains("AXIS")) { string dataTypeAddr = "0x" + dtaddr.ToString("X"); UpdateTableList(datatype, dataTypeAddr); } nav.MoveToParent(); } tableCount++; } } if (tableCount < 1) { Trace.WriteLine("// No tables found specifically for ROM " + id + ", used inherited ROM"); } } WriteIdcTableNames(); } string[] results = new string[2] { ecuid, cpu }; return(results); }
/// <summary> /// Loads this <see cref="BlogMLAttachment"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <returns><b>true</b> if the <see cref="BlogMLAttachment"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="BlogMLAttachment"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source) { bool wasLoaded = false; Guard.ArgumentNotNull(source, "source"); if (source.HasAttributes) { string embeddedAttribute = source.GetAttribute("embedded", String.Empty); string mimeTypeAttribute = source.GetAttribute("mime-type", String.Empty); string sizeAttribute = source.GetAttribute("size", String.Empty); string externalUriAttribute = source.GetAttribute("external-uri", String.Empty); string urlAttribute = source.GetAttribute("url", String.Empty); if (!String.IsNullOrEmpty(embeddedAttribute)) { bool isEmbedded; if (Boolean.TryParse(embeddedAttribute, out isEmbedded)) { this.IsEmbedded = isEmbedded; wasLoaded = true; } } if (!String.IsNullOrEmpty(mimeTypeAttribute)) { this.MimeType = mimeTypeAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(sizeAttribute)) { long size; if (Int64.TryParse(sizeAttribute, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out size)) { this.Size = size; wasLoaded = true; } } if (!String.IsNullOrEmpty(externalUriAttribute)) { Uri externalUri; if (Uri.TryCreate(externalUriAttribute, UriKind.RelativeOrAbsolute, out externalUri)) { this.ExternalUri = externalUri; wasLoaded = true; } } if (!String.IsNullOrEmpty(urlAttribute)) { Uri url; if (Uri.TryCreate(urlAttribute, UriKind.RelativeOrAbsolute, out url)) { this.Url = url; wasLoaded = true; } } } if (!String.IsNullOrEmpty(source.Value)) { this.Content = source.Value; wasLoaded = true; } return(wasLoaded); }
public static int Main(string[] args) { // write banner ConsoleApplication.WriteBanner(); // specify options OptionCollection options = new OptionCollection(); options.Add(new SwitchOption("?", "Show this help page.")); options.Add(new StringOption("out", "Specify an output file. If unspecified, output goes to the console.", "outputFilePath")); options.Add(new StringOption("config", "Specify a configuration file. If unspecified, MRefBuilder.config is used", "configFilePath")); options.Add(new ListOption("dep", "Speficy assemblies to load for dependencies.", "dependencyAssembly")); // options.Add( new BooleanOption("namespaces", "Control whether information on namespaces in provided.") ); options.Add(new BooleanOption("internal", "Specify whether to document internal as well as externally exposed APIs.")); // process options ParseArgumentsResult results = options.ParseArguments(args); if (results.Options["?"].IsPresent) { Console.WriteLine("MRefBuilder [options] assemblies"); options.WriteOptionSummary(Console.Out); return(0); } // check for invalid options if (!results.Success) { results.WriteParseErrors(Console.Out); return(1); } // check for missing or extra assembly directories if (results.UnusedArguments.Count < 1) { Console.WriteLine("Specify at least one assembly to reflect."); return(1); } // load the configuration file XPathDocument config; string configDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); string configFile = Path.Combine(configDirectory, "MRefBuilder.config"); if (results.Options["config"].IsPresent) { configFile = (string)results.Options["config"].Value; configDirectory = Path.GetDirectoryName(configFile); } try { config = new XPathDocument(configFile); } catch (IOException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("An error occured while attempting to read the configuration file '{0}'. The error message is: {1}", configFile, e.Message)); return(1); } catch (UnauthorizedAccessException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("An error occured while attempting to read the configuration file '{0}'. The error message is: {1}", configFile, e.Message)); return(1); } catch (XmlException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The configuration file '{0}' is not well-formed. The error message is: {1}", configFile, e.Message)); return(1); } // adjust the target platform XPathNodeIterator platformNodes = config.CreateNavigator().Select("/configuration/dduetools/platform"); if (platformNodes.MoveNext()) { XPathNavigator platformNode = platformNodes.Current; string version = platformNode.GetAttribute("version", String.Empty); string path = platformNode.GetAttribute("path", String.Empty); path = Environment.ExpandEnvironmentVariables(path); if (!Directory.Exists(path)) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The specifed target platform directory '{0}' does not exist.", path)); return(1); } if (version == "2.0") { TargetPlatform.SetToV2(path); } else if (version == "1.1") { TargetPlatform.SetToV1_1(path); } else if (version == "1.0") { TargetPlatform.SetToV1(path); } else { Console.WriteLine("Unknown target platform version '{0}'.", version); return(1); } } // create a namer ApiNamer namer = new OrcasNamer(); XPathNavigator namerNode = config.CreateNavigator().SelectSingleNode("/configuration/dduetools/namer"); if (namerNode != null) { string assemblyPath = namerNode.GetAttribute("assembly", String.Empty); string typeName = namerNode.GetAttribute("type", String.Empty); assemblyPath = Environment.ExpandEnvironmentVariables(assemblyPath); if (!Path.IsPathRooted(assemblyPath)) { assemblyPath = Path.Combine(configDirectory, assemblyPath); } try { Assembly assembly = Assembly.LoadFrom(assemblyPath); namer = (ApiNamer)assembly.CreateInstance(typeName); if (namer == null) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The type '{0}' was not found in the component assembly '{1}'.", typeName, assemblyPath)); return(1); } } catch (IOException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("A file access error occured while attempting to load the component assembly '{0}'. The error message is: {1}", assemblyPath, e.Message)); return(1); } catch (UnauthorizedAccessException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("A file access error occured while attempting to load the component assembly '{0}'. The error message is: {1}", assemblyPath, e.Message)); return(1); } catch (BadImageFormatException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The component assembly '{0}' is not a valid managed assembly.", assemblyPath)); return(1); } catch (TypeLoadException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The type '{0}' was not found in the component assembly '{1}'.", typeName, assemblyPath)); return(1); } catch (MissingMethodException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("No appropriate constructor exists for the type'{0}' in the component assembly '{1}'.", typeName, assemblyPath)); return(1); } catch (TargetInvocationException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("An error occured while initializing the type '{0}' in the component assembly '{1}'. The error message and stack trace follows: {2}", typeName, assemblyPath, e.InnerException.ToString())); return(1); } catch (InvalidCastException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The type '{0}' in the component assembly '{1}' is not a component type.", typeName, assemblyPath)); return(1); } } // create a resolver AssemblyResolver resolver = new AssemblyResolver(); XPathNavigator resolverNode = config.CreateNavigator().SelectSingleNode("/configuration/dduetools/resolver"); if (resolverNode != null) { string assemblyPath = resolverNode.GetAttribute("assembly", String.Empty); string typeName = resolverNode.GetAttribute("type", String.Empty); assemblyPath = Environment.ExpandEnvironmentVariables(assemblyPath); if (!Path.IsPathRooted(assemblyPath)) { assemblyPath = Path.Combine(configDirectory, assemblyPath); } try { Assembly assembly = Assembly.LoadFrom(assemblyPath); resolver = (AssemblyResolver)assembly.CreateInstance(typeName, false, BindingFlags.Public | BindingFlags.Instance, null, new Object[1] { resolverNode }, null, null); if (resolver == null) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The type '{0}' was not found in the component assembly '{1}'.", typeName, assemblyPath)); return(1); } } catch (IOException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("A file access error occured while attempting to load the component assembly '{0}'. The error message is: {1}", assemblyPath, e.Message)); return(1); } catch (UnauthorizedAccessException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("A file access error occured while attempting to load the component assembly '{0}'. The error message is: {1}", assemblyPath, e.Message)); return(1); } catch (BadImageFormatException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The component assembly '{0}' is not a valid managed assembly.", assemblyPath)); return(1); } catch (TypeLoadException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The type '{0}' was not found in the component assembly '{1}'.", typeName, assemblyPath)); return(1); } catch (MissingMethodException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("No appropriate constructor exists for the type'{0}' in the component assembly '{1}'.", typeName, assemblyPath)); return(1); } catch (TargetInvocationException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("An error occured while initializing the type '{0}' in the component assembly '{1}'. The error message and stack trace follows: {2}", typeName, assemblyPath, e.InnerException.ToString())); return(1); } catch (InvalidCastException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The type '{0}' in the component assembly '{1}' is not a component type.", typeName, assemblyPath)); return(1); } } resolver.UnresolvedAssemblyReference += new EventHandler <AssemblyReferenceEventArgs>(UnresolvedAssemblyReferenceHandler); // get a textwriter for output TextWriter output = Console.Out; if (results.Options["out"].IsPresent) { string file = (string)results.Options["out"].Value; try { output = new StreamWriter(file, false, Encoding.UTF8); } catch (IOException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("An error occured while attempting to create an output file. The error message is: {0}", e.Message)); return(1); } catch (UnauthorizedAccessException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("An error occured while attempting to create an output file. The error message is: {0}", e.Message)); return(1); } } // dependency directory string[] dependencies = new string[0]; if (results.Options["dep"].IsPresent) { dependencies = (string[])results.Options["dep"].Value; } try { // create a builder ManagedReflectionWriter builder = new ManagedReflectionWriter(output, namer); // specify the resolver for the builder builder.Resolver = resolver; // builder.ApiFilter = new ExternalDocumentedFilter(config.CreateNavigator().SelectSingleNode("/configuration/dduetools")); // specify the filter for the builder if (results.Options["internal"].IsPresent && (bool)results.Options["internal"].Value) { builder.ApiFilter = new AllDocumentedFilter(config.CreateNavigator().SelectSingleNode("/configuration/dduetools")); } else { builder.ApiFilter = new ExternalDocumentedFilter(config.CreateNavigator().SelectSingleNode("/configuration/dduetools")); } // register add-ins to the builder XPathNodeIterator addinNodes = config.CreateNavigator().Select("/configuration/dduetools/addins/addin"); foreach (XPathNavigator addinNode in addinNodes) { string assemblyPath = addinNode.GetAttribute("assembly", String.Empty); string typeName = addinNode.GetAttribute("type", String.Empty); assemblyPath = Environment.ExpandEnvironmentVariables(assemblyPath); if (!Path.IsPathRooted(assemblyPath)) { assemblyPath = Path.Combine(configDirectory, assemblyPath); } try { Assembly assembly = Assembly.LoadFrom(assemblyPath); MRefBuilderAddIn addin = (MRefBuilderAddIn)assembly.CreateInstance(typeName, false, BindingFlags.Public | BindingFlags.Instance, null, new Object[2] { builder, addinNode }, null, null); if (namer == null) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The type '{0}' was not found in the addin assembly '{1}'.", typeName, assemblyPath)); return(1); } } catch (IOException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("A file access error occured while attempting to load the addin assembly '{0}'. The error message is: {1}", assemblyPath, e.Message)); return(1); } catch (BadImageFormatException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The addin assembly '{0}' is not a valid managed assembly.", assemblyPath)); return(1); } catch (TypeLoadException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The type '{0}' was not found in the addin assembly '{1}'.", typeName, assemblyPath)); return(1); } catch (MissingMethodException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("No appropriate constructor exists for the type '{0}' in the addin assembly '{1}'.", typeName, assemblyPath)); return(1); } catch (TargetInvocationException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("An error occured while initializing the type '{0}' in the addin assembly '{1}'. The error message and stack trace follows: {2}", typeName, assemblyPath, e.InnerException.ToString())); return(1); } catch (InvalidCastException) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("The type '{0}' in the addin assembly '{1}' is not an MRefBuilderAddIn type.", typeName, assemblyPath)); return(1); } } try { // add a handler for unresolved assembly references //builder.UnresolvedModuleHandler = new System.Compiler.Module.AssemblyReferenceResolver(AssemblyNotFound); // load dependent bits foreach (string dependency in dependencies) { try { builder.LoadAccessoryAssemblies(dependency); } catch (IOException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("An error occured while loading dependency assemblies. The error message is: {0}", e.Message)); return(1); } } // parse the bits foreach (string dllPath in results.UnusedArguments) { try { builder.LoadAssemblies(dllPath); } catch (IOException e) { ConsoleApplication.WriteMessage(LogLevel.Error, String.Format("An error occured while loading assemblies for reflection. The error message is: {0}", e.Message)); return(1); } } ConsoleApplication.WriteMessage(LogLevel.Info, String.Format("Loaded {0} assemblies for reflection and {1} dependency assemblies.", builder.Assemblies.Length, builder.AccessoryAssemblies.Length)); // register callbacks //builder.RegisterStartTagCallback("apis", new MRefBuilderCallback(startTestCallback)); //MRefBuilderAddIn addin = new XamlAttachedMembersAddIn(builder, null); builder.VisitApis(); ConsoleApplication.WriteMessage(LogLevel.Info, String.Format("Wrote information on {0} namespaces, {1} types, and {2} members", builder.Namespaces.Length, builder.Types.Length, builder.Members.Length)); } finally { builder.Dispose(); } } finally { // output.Close(); } return(0); }
//===================================================================== /// <summary> /// Create a binding redirect settings instance from an XPath navigator /// containing the settings. /// </summary> /// <param name="pathProvider">The base path provider object</param> /// <param name="navigator">The XPath navigator from which to /// obtain the settings.</param> /// <returns>A <see cref="BindingRedirectSettings"/> object containing /// the settings from the XPath navigator.</returns> /// <remarks>It should contain an element called <c>dependentAssembly</c> /// with a configFile attribute or a nested <c>assemblyIdentity</c> and /// <c>bindingRedirect</c> element that define the settings.</remarks> public static BindingRedirectSettings FromXPathNavigator( IBasePathProvider pathProvider, XPathNavigator navigator) { BindingRedirectSettings brs = new BindingRedirectSettings(pathProvider); XPathNavigator nav; string value; string[] versions; Version tempVersion; if (navigator != null) { value = navigator.GetAttribute("importFrom", String.Empty).Trim(); if (value.Length != 0) { brs.ConfigurationFile = new FilePath(value, pathProvider); } else { nav = navigator.SelectSingleNode("assemblyIdentity"); if (nav != null) { brs.AssemblyName = nav.GetAttribute("name", String.Empty).Trim(); brs.PublicKeyToken = nav.GetAttribute("publicKeyToken", String.Empty).Trim(); brs.Culture = nav.GetAttribute("culture", String.Empty).Trim(); } nav = navigator.SelectSingleNode("bindingRedirect"); if (nav != null) { value = nav.GetAttribute("newVersion", String.Empty).Trim(); if (value.Length != 0) { brs.NewVersion = new Version(value); } value = nav.GetAttribute("oldVersion", String.Empty).Trim(); versions = value.Split('-'); if (versions.Length == 2) { if (versions[0].Trim().Length != 0) { brs.OldVersion = new Version(versions[0]); } if (versions[1].Trim().Length != 0) { brs.OldVersionTo = new Version(versions[1]); } if (brs.OldVersion > brs.oldVersionTo) { tempVersion = brs.OldVersion; brs.OldVersion = brs.oldVersionTo; brs.oldVersionTo = tempVersion; } } else { brs.OldVersion = new Version(versions[0]); } } } } return(brs); }
public override void LoadAdditionals(XPathNavigator reader) { Size = (MemoryVariableSize)Enum.Parse(typeof(MemoryVariableSize), reader.GetAttribute("Size", reader.NamespaceURI)); }
//============================================================ // PUBLIC METHODS //============================================================ #region Fill(AtomCategoryDocument resource) /// <summary> /// Modifies the <see cref="AtomCategoryDocument"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="AtomCategoryDocument"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(AtomCategoryDocument resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = AtomUtility.CreateNamespaceManager(this.Navigator.NameTable); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator documentNavigator = this.Navigator.SelectSingleNode("app:categories", manager); if (documentNavigator != null) { AtomUtility.FillCommonObjectAttributes(resource, documentNavigator); if (documentNavigator.HasChildren) { if (documentNavigator.HasAttributes) { string fixedAttribute = documentNavigator.GetAttribute("fixed", String.Empty); string schemeAttribute = documentNavigator.GetAttribute("scheme", String.Empty); string hrefAttribute = documentNavigator.GetAttribute("href", String.Empty); if (!String.IsNullOrEmpty(fixedAttribute)) { if (String.Compare(fixedAttribute, "yes", StringComparison.OrdinalIgnoreCase) == 0) { resource.IsFixed = true; } else if (String.Compare(fixedAttribute, "no", StringComparison.OrdinalIgnoreCase) == 0) { resource.IsFixed = false; } } if (!String.IsNullOrEmpty(schemeAttribute)) { Uri scheme; if (Uri.TryCreate(schemeAttribute, UriKind.RelativeOrAbsolute, out scheme)) { resource.Scheme = scheme; } } if (!String.IsNullOrEmpty(hrefAttribute)) { Uri href; if (Uri.TryCreate(hrefAttribute, UriKind.RelativeOrAbsolute, out href)) { resource.Uri = href; } } } if (documentNavigator.HasChildren) { XPathNodeIterator categoryIterator = documentNavigator.Select("atom:category", manager); if (categoryIterator != null && categoryIterator.Count > 0) { while (categoryIterator.MoveNext()) { AtomCategory category = new AtomCategory(); if (category.Load(categoryIterator.Current, this.Settings)) { resource.AddCategory(category); } } } } } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(documentNavigator, this.Settings); adapter.Fill(resource, manager); } }
//============================================================ // PUBLIC METHODS //============================================================ #region Fill(BlogMLDocument resource) /// <summary> /// Modifies the <see cref="BlogMLDocument"/> to match the data source. /// </summary> /// <param name="resource">The <see cref="BlogMLDocument"/> to be filled.</param> /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception> public void Fill(BlogMLDocument resource) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(resource, "resource"); //------------------------------------------------------------ // Create namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = BlogMLUtility.CreateNamespaceManager(this.Navigator.NameTable); //------------------------------------------------------------ // Attempt to fill syndication resource //------------------------------------------------------------ XPathNavigator blogNavigator = this.Navigator.SelectSingleNode("blog:blog", manager); if (blogNavigator != null) { if (blogNavigator.HasAttributes) { string dateCreatedAttribute = blogNavigator.GetAttribute("date-created", String.Empty); string rootUrlAttribute = blogNavigator.GetAttribute("root-url", String.Empty); if (!String.IsNullOrEmpty(dateCreatedAttribute)) { DateTime createdOn; if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(dateCreatedAttribute, out createdOn)) { resource.GeneratedOn = createdOn; } } if (!String.IsNullOrEmpty(rootUrlAttribute)) { Uri rootUrl; if (Uri.TryCreate(rootUrlAttribute, UriKind.RelativeOrAbsolute, out rootUrl)) { resource.RootUrl = rootUrl; } } } if (blogNavigator.HasChildren) { XPathNavigator titleNavigator = blogNavigator.SelectSingleNode("blog:title", manager); XPathNavigator subtitleNavigator = blogNavigator.SelectSingleNode("blog:sub-title", manager); if (titleNavigator != null) { BlogMLTextConstruct title = new BlogMLTextConstruct(); if (title.Load(titleNavigator)) { resource.Title = title; } } if (subtitleNavigator != null) { BlogMLTextConstruct subtitle = new BlogMLTextConstruct(); if (subtitle.Load(subtitleNavigator)) { resource.Subtitle = subtitle; } } BlogML20SyndicationResourceAdapter.FillDocumentCollections(resource, blogNavigator, manager, this.Settings); } SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(blogNavigator, this.Settings); adapter.Fill(resource, manager); } }
private static void WriteStandardParameters(string target, string ecuid, uint ssmBase, string cpu, string loggerdef) { Trace.WriteLine("auto addr;"); if (target == "ecu" | target == "ECU") { target = "2"; } if (target == "tcu" | target == "TCU") { target = "1"; } string ptrName = "PtrSsmGet_"; string funcName = "SsmGet_"; if (cpu.Equals("16")) { ptrName = "PtrSsm_"; funcName = "Ssm_"; Trace.WriteLine("auto opAddr, seg;"); Trace.WriteLine("if (SegByName(\"DATA\") != BADADDR) seg = 1;"); Trace.WriteLine(""); } using (Stream stream = File.OpenRead(loggerdef)) { XPathDocument doc = new XPathDocument(stream); XPathNavigator nav = doc.CreateNavigator(); string path = "/logger/protocols/protocol[@id='SSM']/parameters/parameter"; XPathNodeIterator iter = nav.Select(path); string id = ""; while (iter.MoveNext()) { XPathNavigator navigator = iter.Current; if (navigator.GetAttribute("target", "") == target) { continue; } string name = navigator.GetAttribute("name", ""); id = navigator.GetAttribute("id", ""); if (cpu.Equals("16") && id.Equals("P89")) { continue; } name = name + "_" + id.Trim(); string pointerName = ConvertName(ptrName + name); string functionName = ConvertName(funcName + name); if (!navigator.MoveToChild("address", "")) { continue; } string addressString = iter.Current.InnerXml; addressString = addressString.Substring(2); uint address = uint.Parse(addressString, System.Globalization.NumberStyles.HexNumber); if (cpu.Equals("16") && address > 0x18F) // addresses over this will overrun DTC structure { continue; } address = address * 4; address = address + ssmBase; addressString = "0x" + address.ToString("X8"); Trace.WriteLine(string.Format("MakeUnknown({0}, 4, DOUNK_SIMPLE);", addressString)); Trace.WriteLine(string.Format("MakeDword({0});", addressString)); MakeName(addressString, pointerName); string getAddress = string.Format("addr = Dword({0});", addressString); Trace.WriteLine(getAddress); MakeName("addr", functionName); if (cpu.Equals("16")) { string length = "1"; length = navigator.GetAttribute("length", ""); FormatData("addr", length); string fGetter = ConvertName("SsmGet_" + name); StringBuilder builder = new StringBuilder(); builder.AppendLine("opAddr = FindImmediate(0, 0x21, (addr - 0x20000));"); builder.AppendLine("addr = GetFunctionAttr(opAddr, FUNCATTR_START);"); builder.AppendLine("if (addr != BADADDR)"); builder.AppendLine("{"); builder.AppendLine(" if (seg)"); builder.AppendLine(" {"); builder.AppendLine(" OpAlt(opAddr, 0, \"\");"); builder.AppendLine(" OpOff(MK_FP(\"ROM\", opAddr), 0, 0x20000);"); builder.AppendLine(" }"); builder.AppendLine(" add_dref(opAddr, Dword(" + addressString + "), dr_I);"); string command = string.Format(" MakeNameEx(addr, \"{0}\", SN_CHECK);", fGetter); builder.AppendLine(command); builder.AppendLine("}"); builder.AppendLine("else"); builder.AppendLine("{"); builder.AppendLine(" Message(\"No reference to " + name + "\\n\");"); builder.AppendLine("}"); Trace.Write(builder.ToString()); } Trace.WriteLine(""); } // now let's print the switch references // Name format: Switches_b7_b6_b5_b4_b3_b2_b1_b0 IDictionary <string, Array> switchList = new Dictionary <string, Array>(); path = "/logger/protocols/protocol[@id='SSM']/switches/switch"; iter = nav.Select(path); string bit = ""; while (iter.MoveNext()) { XPathNavigator navigator = iter.Current; if (navigator.GetAttribute("target", "") == target) { continue; } id = navigator.GetAttribute("id", ""); id = id.Replace("S", ""); string addr = navigator.GetAttribute("byte", ""); addr = addr.Substring(2); bit = navigator.GetAttribute("bit", ""); Array values; if (!switchList.TryGetValue(addr, out values)) { string[] temp = new string[8] { "x", "x", "x", "x", "x", "x", "x", "x" }; switchList.Add(addr, temp); } if (switchList.TryGetValue(addr, out values)) { uint i = uint.Parse(bit, System.Globalization.NumberStyles.HexNumber); values.SetValue(id.Trim(), i); Array.Copy(values, switchList[addr], values.Length); } } PrintSwitches(switchList, ssmBase, cpu); } }
/// <summary> /// See <see cref="XPathNavigator.GetAttribute"/>. /// </summary> public override string GetAttribute(string localName, string namespaceURI) { return(AtRoot ? String.Empty : _navigator.GetAttribute(localName, namespaceURI)); }
/// <include file='doc\XPathNavigator.uex' path='docs/doc[@for="XPathNavigator.GetAttribute"]/*' /> public override string GetAttribute(string localName, string namespaceURI) { return(_xn.GetAttribute(localName, namespaceURI)); }
public static string GetAttributeValue(XPathNavigator nav, string AttributeName) { return(nav.GetAttribute(AttributeName, "")); }
// Set soundbank-related bool settings in the wproj file. public static bool EnableBoolSoundbankSettingInWproj(string SettingName, string WwiseProjectPath) { try { if (WwiseProjectPath.Length == 0) { // The setup should not fail if there is no wproj file set. Silently succeed. return(true); } XmlDocument doc = new XmlDocument(); doc.PreserveWhitespace = true; doc.Load(WwiseProjectPath); XPathNavigator Navigator = doc.CreateNavigator(); // Navigate the wproj file (XML format) to where our setting should be string pathInXml = String.Format("/WwiseDocument/ProjectInfo/Project/PropertyList/Property[@Name='{0}']", SettingName); XPathExpression expression = XPathExpression.Compile(pathInXml); XPathNavigator node = Navigator.SelectSingleNode(expression); if (node == null) { // Setting isn't in the wproj, add it // Navigate to the SoundBankHeaderFilePath property (it is always there) expression = XPathExpression.Compile("/WwiseDocument/ProjectInfo/Project/PropertyList/Property[@Name='SoundBankHeaderFilePath']"); node = Navigator.SelectSingleNode(expression); if (node == null) { // SoundBankHeaderFilePath not in wproj, invalid wproj file UnityEngine.Debug.LogError("Could not find SoundBankHeaderFilePath property in Wwise project file. File is invalid."); return(false); } // Add the setting right above SoundBankHeaderFilePath string propertyToInsert = string.Format("<Property Name=\"{0}\" Type=\"bool\" Value=\"True\"/>", SettingName); node.InsertBefore(propertyToInsert); } else { // Value is present, we simply have to modify it. if (node.GetAttribute("Value", "") == "False") { // Modify the value to true if (!node.MoveToAttribute("Value", "")) { return(false); } node.SetValue("True"); } else { // Parameter already set, nothing to do! return(true); } } doc.Save(WwiseProjectPath); } catch (Exception) { return(false); } return(true); }
/// <inheritdoc /> public override void WritePropertySyntax(XPathNavigator reflection, SyntaxWriter writer) { bool isSettable = (bool)reflection.Evaluate(apiIsWritePropertyExpression); bool isSetterPublic = (bool)reflection.Evaluate(apiIsSetterPublicExpression); bool isAbstract = (bool)reflection.Evaluate(apiIsAbstractProcedureExpression); string propertyVisibility = (string)reflection.Evaluate(apiVisibilityExpression); XPathNodeIterator parameters = reflection.Select(apiParametersExpression); XPathNavigator returnType = reflection.SelectSingleNode(apiReturnTypeExpression); bool notWriteableReturnType = (bool)returnType.Evaluate(noSettablePropertiesExpression); string returnTypeId = returnType.GetAttribute("api", string.Empty); string returnTypeSubgroup = (string)returnType.Evaluate(apiSubgroupExpression); bool returnTypeIsAbstract = (bool)returnType.Evaluate(apiIsAbstractTypeExpression); bool returnTypeIsReadonlyStruct = (returnTypeSubgroup == "structure" && notWriteableReturnType && !IsPrimitiveType(returnTypeId)); XPathNavigator containingType = reflection.SelectSingleNode(apiContainingTypeExpression); string containingTypeSubgroup = (string)containingType.Evaluate(apiSubgroupExpression); // an ordinary property, not an attached prop if (containingTypeSubgroup == "interface") { WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_noXamlSyntaxForInterfaceMembers, writer); } else if ((bool)containingType.Evaluate(apiIsAbstractTypeExpression) && (bool)containingType.Evaluate(apiIsSealedTypeExpression)) { // the property's containing type is static if it's abstract and sealed // members of a static class cannot be used in XAML. WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_nonXamlParent, writer); } else if (IsExcludedSubClass(containingType)) { WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_parentIsExcludedSubClass, writer); } else if (!DoesParentSupportXaml(reflection)) { WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_nonXamlParent, writer); } else if (propertyVisibility != "public") { WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_notPublic, writer); } else if (isAbstract) { WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_abstract, writer); } else if (parameters.Count > 0) { // per DDUERELTools bug 1373: indexer properties cannot be used in XAML WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_nonXaml, writer); } else if (IsContentProperty(reflection) && !returnTypeIsReadonlyStruct) { PropertyContentElementUsageSimple(reflection, writer); } else if (!isSettable || !isSetterPublic) { WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_readOnly, writer); } else if (returnTypeIsAbstract && !HasTypeConverterAttribute(returnType)) // !EFW - Allow it if there's a type converter { WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_abstractType, returnType, writer); } else if (IsPrimitiveType(returnTypeId)) { PropertyAttributeUsage(reflection, writer); } else if (returnTypeSubgroup == "enumeration") { PropertyAttributeUsage(reflection, writer); } else { bool hasDefaultConstructor = HasDefaultConstructor(returnType); if (HasTypeConverterAttribute(returnType)) { if (hasDefaultConstructor && !returnTypeIsReadonlyStruct) { PropertyElementUsageGrande(reflection, writer); } PropertyAttributeUsage(reflection, writer); } else if (hasDefaultConstructor && !returnTypeIsReadonlyStruct) { PropertyElementUsageGrande(reflection, writer); } else { WriteXamlBoilerplate(XamlBoilerplateID.propertyXamlSyntax_nonXaml, writer); } } }
protected MathComponent(BuildAssembler assembler, XPathNavigator configuration, bool isConceptual) : base(assembler, configuration) { try { _mathNumber = 1; _numberByPage = true; XPathNavigator navigator = configuration.SelectSingleNode("paths"); if (navigator == null) { throw new BuildComponentException( "The input/output paths, or <paths> tag, is required."); } _inputPath = navigator.GetAttribute("inputPath", String.Empty); if (String.IsNullOrEmpty(_inputPath)) { throw new BuildComponentException("The input path is required."); } _inputPath = Environment.ExpandEnvironmentVariables(_inputPath); _inputPath = Path.GetFullPath(_inputPath); // Delete the current input path...to empty the contents. try { if (Directory.Exists(_inputPath)) { Directory.Delete(_inputPath, true); } } catch (Exception ex) { this.WriteMessage(MessageLevel.Warn, ex); } // Create the input path... try { if (!Directory.Exists(_inputPath)) { Directory.CreateDirectory(_inputPath); } } catch (Exception ex) { this.WriteMessage(MessageLevel.Warn, ex); } _outputBasePath = navigator.GetAttribute("baseOutput", String.Empty); if (String.IsNullOrEmpty(_outputBasePath)) { throw new BuildComponentException("The base output path is required."); } _outputBasePath = Environment.ExpandEnvironmentVariables(_outputBasePath); _outputBasePath = Path.GetFullPath(_outputBasePath); _outputPath = navigator.GetAttribute("outputPath", String.Empty); if (String.IsNullOrEmpty(_outputPath)) { throw new BuildComponentException("The output path is required."); } _outputPath = Environment.ExpandEnvironmentVariables(_outputPath); _outputPath = Path.Combine(_outputBasePath, _outputPath); try { if (!Directory.Exists(_outputPath)) { Directory.CreateDirectory(_outputPath); } } catch (Exception ex) { this.WriteMessage(MessageLevel.Warn, ex); } //_linkPath = navigator.GetAttribute("link", String.Empty); //if (_linkPath[_linkPath.Length - 1] != '/') //{ // _linkPath = _linkPath + "/"; //} navigator = configuration.SelectSingleNode("numbering"); if (navigator != null) { string attribute = navigator.GetAttribute("show", String.Empty); if (String.IsNullOrEmpty(attribute) == false) { _numberShow = Convert.ToBoolean(attribute); } attribute = navigator.GetAttribute("byPage", String.Empty); if (String.IsNullOrEmpty(attribute) == false) { _numberByPage = Convert.ToBoolean(attribute); } attribute = navigator.GetAttribute("format", String.Empty); if (String.IsNullOrEmpty(attribute) == false) { _numberFormat = attribute; } attribute = navigator.GetAttribute("formatIncludesPage", String.Empty); if (String.IsNullOrEmpty(attribute) == false) { _numberIncludesPage = Convert.ToBoolean(attribute); } } if (String.IsNullOrEmpty(_numberFormat)) { if (_numberIncludesPage) { _numberFormat = "({0}.{1})"; } else { _numberFormat = "({0})"; } } XPathNodeIterator iterator = configuration.Select("formatter"); if (navigator == null) { throw new BuildComponentException( "At least a formatter is required to use this component."); } Type compType = this.GetType(); MessageWriter msgWriter = assembler.MessageWriter; foreach (XPathNavigator formatter in iterator) { string attribute = formatter.GetAttribute("format", String.Empty); if (String.IsNullOrEmpty(attribute)) { throw new BuildComponentException("The format tag is required."); } if (String.Equals(attribute, "latex", StringComparison.OrdinalIgnoreCase)) { if (_latexFormatter == null) { string latexType = formatter.GetAttribute("type", String.Empty); if (String.Equals(latexType, "MikTeX", StringComparison.OrdinalIgnoreCase)) { _latexFormatter = new MathMikTeXFormatter(compType, msgWriter, formatter); _latexFormatter.BeginUpdate(_inputPath, isConceptual); } else if (String.Equals(latexType, "MimeTeX", StringComparison.OrdinalIgnoreCase)) { _latexFormatter = new MathMimeTeXFormatter( compType, msgWriter, formatter); _latexFormatter.BeginUpdate(_inputPath, isConceptual); } } } } if (_latexFormatter != null) { _latexFormatter.Update(configuration); navigator = configuration.SelectSingleNode("naming"); if (navigator != null) { MathNamingMethod namingMethod = MathNamingMethod.Sequential; string attribute = navigator.GetAttribute("method", String.Empty); if (String.IsNullOrEmpty(attribute) == false) { namingMethod = (MathNamingMethod)Enum.Parse( typeof(MathNamingMethod), attribute, true); _latexFormatter.NamingMethod = namingMethod; attribute = navigator.GetAttribute("prefix", String.Empty); if (attribute != null) { _latexFormatter.NamingPrefix = attribute; } } } _latexFormatter.EndUpdate(); } // Check the availability of a LaTeX distribution... _latexPath = SearchExecutable("latex.exe"); _isLaTeXInstalled = (!String.IsNullOrEmpty(_latexPath) && File.Exists(_latexPath)); // Warn if no distribution is found... if (!_isLaTeXInstalled) { this.WriteMessage(MessageLevel.Warn, "There is no LaTeX installation found. Please installed the MikTeX (http://www.miktex.org/)."); } } catch (Exception ex) { this.WriteMessage(MessageLevel.Error, ex); } }
/// <summary> /// Create an (single or sequence) Attribute instance using a raw xml file (that is generated by the ODD). /// </summary> /// <param name="attributeNode">An Attribute node.</param> /// <returns>The created Attribute instance.</returns> public static Attribute Create(XPathNavigator attributeNode, AttributesAndMacros parent) { Attribute attribute = null; // Return value; string name = string.Empty; Tag tag = new Tag(); // // Determine attribute name. // try { name = attributeNode.GetAttribute("Name", ""); } catch (Exception exception) { throw (DefinitionFile.CreateException(attributeNode, "Attribute", "Unable to determine Name", exception)); } // // Determine tag. // tag = Tag.Create(attributeNode); // // Construct a single attribute or a sequence attribute. // VR valueRepresentations = VR.None; XPathNodeIterator vRNodes = attributeNode.Select("VR"); if (vRNodes.MoveNext()) { try { valueRepresentations = (VR)System.Enum.Parse(typeof(VR), vRNodes.Current.Value.Replace('/', ',')); } catch { throw (DefinitionFile.CreateException(attributeNode, "Attribute", "VR node does not contain a valid VR.", null)); } } else { throw (DefinitionFile.CreateException(attributeNode, "Attribute", "VR node not found.", null)); } if (valueRepresentations == VR.SQ) { attribute = SequenceAttribute.Create(tag, name, attributeNode, parent); } else { attribute = new SingleAttribute(tag, valueRepresentations, name, parent); } // // Return the constructed attribute. // return(attribute); }
//===================================================================== /// <summary> /// This is used to create an MSDN resolver for the reference link to use in looking up MSDN content iDs /// </summary> /// <param name="configuration">The component configuration</param> /// <returns>An MSDN resolver instance</returns> /// <remarks>This can be overridden in derived classes to provide persistent caches with backing stores /// other than the default dictionary serialized to a binary file. It also allows sharing the cache /// across instances by placing it in the <see cref="BuildComponentCore.Data"/> dictionary using the key /// name <c>SharedMsdnContentIdCacheID</c>. /// /// <para>If overridden, the <see cref="UpdateMsdnContentIdCache"/> method should also be overridden to /// persist changes to the cache if needed.</para></remarks> protected virtual MsdnResolver CreateMsdnResolver(XPathNavigator configuration) { MsdnResolver newResolver; IDictionary <string, string> cache = null; if (BuildComponentCore.Data.ContainsKey(SharedMsdnContentIdCacheId)) { cache = BuildComponentCore.Data[SharedMsdnContentIdCacheId] as IDictionary <string, string>; } // If the shared cache already exists, return an instance that uses it. It is assumed that all // subsequent instances will use the same cache. if (cache != null) { return(new MsdnResolver(cache, true)); } // If a <cache> element is not specified, we'll use the standard resolver without a persistent cache. // We will share it across all instances though. XPathNavigator node = configuration.SelectSingleNode("msdnContentIdCache"); if (node == null) { newResolver = new MsdnResolver(); } else { // Keep the filename. If we own it, we'll update the cache file when disposed. msdnIdCacheFile = node.GetAttribute("path", String.Empty); if (String.IsNullOrWhiteSpace(msdnIdCacheFile)) { base.WriteMessage(MessageLevel.Error, "You must specify a path attribute value on the " + "msdnContentIdCache element."); } // Create the folder if it doesn't exist msdnIdCacheFile = Path.GetFullPath(Environment.ExpandEnvironmentVariables(msdnIdCacheFile)); string path = Path.GetDirectoryName(msdnIdCacheFile); if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } // Load the cache if it exists if (!File.Exists(msdnIdCacheFile)) { // Logged as a diagnostic message since looking up all IDs can significantly slow the build base.WriteMessage(MessageLevel.Diagnostic, "The MSDN content ID cache '" + msdnIdCacheFile + "' does not exist yet. All IDs will be looked up in this build which will slow it down."); newResolver = new MsdnResolver(); } else { using (FileStream fs = new FileStream(msdnIdCacheFile, FileMode.Open, FileAccess.Read, FileShare.Read)) { BinaryFormatter bf = new BinaryFormatter(); newResolver = new MsdnResolver((IDictionary <string, string>)bf.Deserialize(fs), false); base.WriteMessage(MessageLevel.Info, "Loaded {0} cached MSDN content ID entries", newResolver.MsdnContentIdCache.Count); } } } BuildComponentCore.Data[SharedMsdnContentIdCacheId] = newResolver.MsdnContentIdCache; return(newResolver); }
// the actual work of the component public override void Apply(XmlDocument document, string key) { // set the key in the XPath context _context["key"] = key; // perform each copy action foreach (CopyFromIndexCommand copyCommand in _copyCommands) { // get the source comment XPathExpression keyExpression = copyCommand.Key.Clone(); keyExpression.SetContext(_context); string keyValue = (string)document.CreateNavigator().Evaluate(keyExpression); if (String.IsNullOrEmpty(keyValue)) { continue; } XPathNavigator data = copyCommand.Index.GetContent(keyValue); if (data == null && copyCommand.IgnoreCase == "true") { data = copyCommand.Index.GetContent(keyValue.ToLower()); } // notify if no entry if (data == null) { WriteMessage(copyCommand.MissingEntry, String.Format( "No index entry found for key '{0}'.", keyValue)); continue; } // get the target node String targetXPath = copyCommand.Target.Clone().ToString(); XPathExpression target_expression = XPathExpression.Compile( String.Format(targetXPath, keyValue)); target_expression.SetContext(_context); XPathNavigator target = document.CreateNavigator().SelectSingleNode(target_expression); // notify if no target found if (target == null) { WriteMessage(copyCommand.MissingTarget, String.Format("Target node '{0}' not found.", target_expression.Expression)); continue; } // get the source nodes XPathExpression sourceExpression = copyCommand.Source.Clone(); sourceExpression.SetContext(_context); XPathNodeIterator sources = data.CreateNavigator().Select(sourceExpression); // append the source nodes to the target node int sourceCount = 0; foreach (XPathNavigator source in sources) { sourceCount++; // If attribute=true, add the source attributes to current target. // Otherwise append source as a child element to target if (copyCommand.Attribute == "true" && source.HasAttributes) { string source_name = source.LocalName; XmlWriter attributes = target.CreateAttributes(); source.MoveToFirstAttribute(); string attrFirst = target.GetAttribute(string.Format("{0}_{1}", source_name, source.Name), string.Empty); if (string.IsNullOrEmpty(attrFirst)) { attributes.WriteAttributeString(string.Format("{0}_{1}", source_name, source.Name), source.Value); } while (source.MoveToNextAttribute()) { string attrNext = target.GetAttribute(string.Format("{0}_{1}", source_name, source.Name), string.Empty); if (string.IsNullOrEmpty(attrNext)) { attributes.WriteAttributeString(string.Format("{0}_{1}", source_name, source.Name), source.Value); } } attributes.Close(); } else { target.AppendChild(source); } } // notify if no source found if (sourceCount == 0) { WriteMessage(copyCommand.MissingSource, String.Format( "Source node '{0}' not found.", sourceExpression.Expression)); } foreach (CopyComponent component in _copyComponents) { component.Apply(document, key); } } }
//============================================================ // PUBLIC METHODS //============================================================ #region Load(XPathNavigator source) /// <summary> /// Loads this <see cref="AtomTextConstruct"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <returns><b>true</b> if the <see cref="AtomTextConstruct"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomTextConstruct"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); //------------------------------------------------------------ // Initialize XML namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = AtomUtility.CreateNamespaceManager(source.NameTable); //------------------------------------------------------------ // Attempt to extract common attributes information //------------------------------------------------------------ if (AtomUtility.FillCommonObjectAttributes(this, source)) { wasLoaded = true; } //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if (source.HasAttributes) { string typeAttribute = source.GetAttribute("type", String.Empty); if (!String.IsNullOrEmpty(typeAttribute)) { AtomTextConstructType type = AtomTextConstruct.ConstructTypeByName(typeAttribute); if (type != AtomTextConstructType.None) { this.TextType = type; wasLoaded = true; } } } if (this.TextType == AtomTextConstructType.Xhtml) { XPathNavigator xhtmlDivNavigator = source.SelectSingleNode("xhtml:div", manager); if (xhtmlDivNavigator != null && !String.IsNullOrEmpty(xhtmlDivNavigator.Value)) { this.Content = xhtmlDivNavigator.Value; wasLoaded = true; } } else if (this.TextType == AtomTextConstructType.Html && !String.IsNullOrEmpty(source.InnerXml)) { this.Content = source.InnerXml; wasLoaded = true; } else if (!String.IsNullOrEmpty(source.Value)) { this.Content = source.Value; wasLoaded = true; } return(wasLoaded); }
//===================================================================== /// <inheritdoc /> public override void Initialize(XPathNavigator configuration) { TargetDictionary newTargets; ReferenceLinkType type; string attrValue, id; targets = new TargetTypeDictionary(); resolver = new LinkTextResolver(targets); // Get the shared instances dictionary. Create it if it doesn't exist. if (BuildComponentCore.Data.ContainsKey(SharedReferenceTargetsId)) { sharedTargets = BuildComponentCore.Data[SharedReferenceTargetsId] as Dictionary <string, TargetDictionary>; } if (sharedTargets == null) { BuildComponentCore.Data[SharedReferenceTargetsId] = sharedTargets = new Dictionary <string, TargetDictionary>(); } // base-url is an xpath expression applied against the current document to pick up the save location of the // document. If specified, local links will be made relative to the base-url. string baseUrlValue = configuration.GetAttribute("base-url", String.Empty); if (!String.IsNullOrEmpty(baseUrlValue)) { baseUrl = XPathExpression.Compile(baseUrlValue); } // hrefFormat is a string format that is used to format the value of local href attributes. The // default is "{0}.htm" if not specified. hrefFormat = (string)configuration.Evaluate("string(hrefFormat/@value)"); if (String.IsNullOrWhiteSpace(hrefFormat)) { hrefFormat = "{0}.htm"; } // The container XPath can be replaced; this is useful string containerValue = configuration.GetAttribute("container", String.Empty); if (!String.IsNullOrEmpty(containerValue)) { XmlTargetDictionaryUtilities.ContainerExpression = containerValue; } XPathNodeIterator targetsNodes = configuration.Select("targets"); #if DEBUG base.WriteMessage(MessageLevel.Diagnostic, "Loading reference link target info"); DateTime startLoad = DateTime.Now; #endif foreach (XPathNavigator targetsNode in targetsNodes) { // Get target type attrValue = targetsNode.GetAttribute("type", String.Empty); if (String.IsNullOrEmpty(attrValue)) { base.WriteMessage(MessageLevel.Error, "Each targets element must have a type attribute " + "that specifies which type of links to create"); } if (!Enum.TryParse <ReferenceLinkType>(attrValue, true, out type)) { base.WriteMessage(MessageLevel.Error, "'{0}' is not a supported reference link type", attrValue); } // Check for shared instance by ID. If not there, create it and add it. id = targetsNode.GetAttribute("id", String.Empty); if (!sharedTargets.TryGetValue(id, out newTargets)) { this.WriteMessage(MessageLevel.Info, "Loading {0} reference link type targets", type); newTargets = this.CreateTargetDictionary(targetsNode); sharedTargets[newTargets.DictionaryId] = newTargets; } targets.Add(type, newTargets); } #if DEBUG TimeSpan loadTime = (DateTime.Now - startLoad); base.WriteMessage(MessageLevel.Diagnostic, "Load time: {0} seconds", loadTime.TotalSeconds); // Dump targets for comparison to other versions // targets.DumpTargetDictionary(Path.GetFullPath("TargetDictionary.xml")); // Serialization test // targets.SerializeDictionary(Directory.GetCurrentDirectory()); #endif // Getting the count from a database cache can be expensive so only report it if it will be seen if (base.BuildAssembler.VerbosityLevel == MessageLevel.Info) { base.WriteMessage(MessageLevel.Info, "{0} total reference link targets", targets.Count); } if (targets.NeedsMsdnResolver) { base.WriteMessage(MessageLevel.Info, "Creating MSDN URL resolver"); msdnResolver = this.CreateMsdnResolver(configuration); string localeValue = (string)configuration.Evaluate("string(locale/@value)"); if (msdnResolver != null && !String.IsNullOrWhiteSpace(localeValue)) { msdnResolver.Locale = localeValue; } } linkTarget = (string)configuration.Evaluate("string(linkTarget/@value)"); if (String.IsNullOrWhiteSpace(linkTarget)) { linkTarget = "_blank"; } }
static string GetAttribute(XPathNavigator nav, string attribute) { return(nav.GetAttribute(attribute, "")); }