public SelectChildren ( XPathNodeType type ) : |
||
type | XPathNodeType | |
리턴 |
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { //<MinValue>-6</MinValue> //<MaxValue>42</MaxValue> foreach (XPathNavigator node in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (node.LocalName) { case MinValueName: int minValue; if (Int32.TryParse(node.InnerXml, out minValue)) _minValue = minValue; break; case MaxValueName: int maxValue; if (Int32.TryParse(node.InnerXml, out maxValue)) _maxValue = maxValue; break; case ShowAsPercentageName: bool perc; if (Boolean.TryParse(node.InnerXml, out perc)) _showAsPercentage = perc; break; } } }
[Test] //ExSkip public void NodeXPathNavigator() { // Create a blank document Document doc = new Document(); // A document is a composite node so we can make a navigator straight away System.Xml.XPath.XPathNavigator navigator = doc.CreateNavigator(); // Our root is the document node with 1 child, which is the first section Assert.AreEqual("Document", navigator.Name); Assert.AreEqual(false, navigator.MoveToNext()); Assert.AreEqual(1, navigator.SelectChildren(XPathNodeType.All).Count); // The document tree has the document, first section, body and first paragraph as nodes, with each being an only child of the previous // We can add a few more to give the tree some branches for the navigator to traverse DocumentBuilder docBuilder = new DocumentBuilder(doc); docBuilder.Write("Section 1, Paragraph 1. "); docBuilder.InsertParagraph(); docBuilder.Write("Section 1, Paragraph 2. "); doc.AppendChild(new Section(doc)); docBuilder.MoveToSection(1); docBuilder.Write("Section 2, Paragraph 1. "); // Use our navigator to print a map of all the nodes in the document to the console StringBuilder stringBuilder = new StringBuilder(); MapDocument(navigator, stringBuilder, 0); Console.Write(stringBuilder.ToString()); }
/// <summary> /// Creates a notification channel from the XML representation. /// </summary> /// <param name="navigator">The navigator to read the information from. </param> /// <returns>The notification channel.</returns> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="navigator"/> parameter is <b>null</b>. /// </exception> /// /// <exception cref="InvalidOperationException"> /// The notification channel defined in the XML is not recognized. /// </exception> public static NotificationChannel Deserialize(XPathNavigator navigator) { Validator.ThrowIfNavigatorNull(navigator); // find out what kind of node we have, and go from there... NotificationChannel channel = null; foreach (XPathNavigator typeSpecificNav in navigator.SelectChildren(XPathNodeType.Element)) { switch (typeSpecificNav.Name) { case "http-notification-channel": channel = new HttpNotificationChannel(); channel.ParseXml(navigator); break; default: throw new InvalidOperationException( String.Format( CultureInfo.InvariantCulture, ResourceRetriever.GetResourceString("UnrecognizedNotificationChannelType"), typeSpecificNav.Name)); } } return channel; }
private DelegateCollection ReadDelegates(XPathNavigator specs) { DelegateCollection delegates = new DelegateCollection(); foreach (XPathNavigator node in specs.SelectChildren("function", String.Empty)) { var name = node.GetAttribute("name", String.Empty); // Check whether we are adding to an existing delegate or creating a new one. Delegate d = null; if (delegates.ContainsKey(name)) { d = delegates[name]; } else { d = new Delegate(); d.Name = name; d.Version = node.GetAttribute("version", String.Empty); d.Category = node.GetAttribute("category", String.Empty); d.DeprecatedVersion = node.GetAttribute("deprecated", String.Empty); d.Deprecated = !String.IsNullOrEmpty(d.DeprecatedVersion); d.Obsolete = node.GetAttribute("obsolete", String.Empty); } foreach (XPathNavigator param in node.SelectChildren(XPathNodeType.Element)) { switch (param.Name) { case "returns": d.ReturnType.CurrentType = param.GetAttribute("type", String.Empty); break; case "param": Parameter p = new Parameter(); p.CurrentType = param.GetAttribute("type", String.Empty); p.Name = param.GetAttribute("name", String.Empty); string element_count = param.GetAttribute("elementcount", String.Empty); if (String.IsNullOrEmpty(element_count)) element_count = param.GetAttribute("count", String.Empty); if (!String.IsNullOrEmpty(element_count)) p.ElementCount = Int32.Parse(element_count); p.Flow = Parameter.GetFlowDirection(param.GetAttribute("flow", String.Empty)); d.Parameters.Add(p); break; } } delegates.Add(d); } return delegates; }
private static string GetElementValue(string elementname, XPathNavigator node) { XPathNodeIterator element = node.SelectChildren(elementname, ""); if (element.Count > 0) { element.MoveNext(); return element.Current.Value; } return String.Empty; }
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { //<ExpectedXmlNamespace>htp://example.com/namespace</ExpectedXmlNamespace> foreach (XPathNavigator element in configurationElement.SelectChildren(XPathNodeType.Element)) { if (element.LocalName != ExpectedXmlNamespaceName) continue; _expectedXmlNamespace = element.InnerXml; return; } }
/// <summary> /// Parses child TestUnit nodes. /// </summary> /// <param name="nav">The parent XPathNavigator which hosts TestUnit nodes.</param> /// <param name="parent">The parent TestSuite to which TestUnits are attached to.</param> /// <param name="collection">The TestResultCollection which will host the result.</param> private static void ParseTestUnitsReport(XPathNavigator nav, TestSuite parent, TestResultCollection collection) { foreach (XPathNavigator child in nav.SelectChildren(Xml.TestSuite, string.Empty)) { ParseTestSuiteReport(child, parent, collection); } foreach (XPathNavigator child in nav.SelectChildren(Xml.TestCase, string.Empty)) { ParseTestCaseReport(child, parent, collection); } }
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { foreach (XPathNavigator element in configurationElement.SelectChildren(XPathNodeType.Element)) { switch(element.LocalName) { case IsTextConfigString: _isText = element.InnerXml == "true"; break; } } }
protected virtual void Parse(XPathNavigator navigator) { sessionFactoryName = navigator.GetAttribute(CfgXmlHelper.SessionFactoryNameAttribute, ""); XPathNodeIterator xpni = navigator.SelectChildren(CfgXmlHelper.PropertiesNodeName, CfgXmlHelper.CfgSchemaXMLNS); while (xpni.MoveNext()) { string propName = xpni.Current.GetAttribute(CfgXmlHelper.PropertyNameAttribute, ""); string propValue = xpni.Current.Value; if (!string.IsNullOrEmpty(propName) && !string.IsNullOrEmpty(propValue)) properties[propName] = propValue; } }
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { base.ParseConfiguration(configurationElement, xmlNamespaceResolver, contentType); foreach (XPathNavigator node in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (node.LocalName) { case UrlFormatName: ParseEnumValue(node.InnerXml, ref _format); break; } } }
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { base.ParseConfiguration(configurationElement, xmlNamespaceResolver, contentType); //<Regex>^[a-zA-Z0-9]*$</Regex> foreach (XPathNavigator element in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (element.LocalName) { case RegexName: _regex = element.InnerXml; break; } } }
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { base.ParseConfiguration(configurationElement, xmlNamespaceResolver, contentType); foreach (XPathNavigator node in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (node.LocalName) { case FormatName: if (!string.IsNullOrEmpty(node.InnerXml)) _format = node.InnerXml; break; } } }
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { //<MinValue>-6</MinValue> //<MaxValue>42</MaxValue> foreach (XPathNavigator node in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (node.LocalName) { case EvenOnlyName: bool evenOnlyValue; if (Boolean.TryParse(node.InnerXml, out evenOnlyValue)) _evenOnly = evenOnlyValue; break; } } base.ParseConfiguration(configurationElement, xmlNamespaceResolver, contentType); }
/// <summary> /// Read all the actions that are children of the actions node /// passed in and return a populated IResourceActions collection /// </summary> /// <param name="actionsNode">The actions node to be read</param> /// <returns>Populated IResourceActions collection</returns> private IResourceActions ReadActions(XPathNavigator actionsNode) { IResourceActions resourceActions = new ResourceActions(); XPathNodeIterator actionNodes = actionsNode.SelectChildren(@"Action", RESOURCE_NAMESPACE_URI); if (actionNodes != null && actionNodes.Count > 0) { while (actionNodes.MoveNext()) { XPathNavigator actionNode = actionNodes.Current; // If the action is already in the resource actions, then // overwrite it i.e. remove it first then add it in again // OK so do it better and more efficiently later IResourceAction resourceAction = ReadAction(actionNode); if (resourceActions.Contains(resourceAction)) { resourceActions.Remove(resourceAction); } resourceActions.Add(resourceAction); // determine the custom data ui handler, probably should be done elsewhere // merged with action loading actually string customUItypeName = (resourceAction as ResourceAction).CustomDataTypeUITypeName; if (customUItypeName != null) { string path = AssemblyLocation.GetPathForActionAssembly(resourceAction.Assembly); try { Assembly assembly = AssemblyLocation.LoadAssemblyFromName(path); resourceAction.CustomDataTypeUI = assembly.CreateInstance(customUItypeName) as ICustomDataType; } catch (Exception e) { StringBuilder sb = new StringBuilder(); sb.Append("XmlResourceReader.ReadAction, trying to load ICustomDataType. "); sb.Append("Ignore exception - custom UI may fail to load because the designer is being used "); sb.Append("from a workstation that doesnt have the action installed. This will be reflected in the designer UI to its user."); Logger.LogDebug(sb.ToString()); Logger.LogDebug(e); } } } } return resourceActions; }
public virtual BaseIterator EvaluateNodeSet(BaseIterator iter) { XPathResultType returnType = this.GetReturnType(iter); switch (returnType) { case XPathResultType.NodeSet: case XPathResultType.Navigator: case XPathResultType.Any: { object obj = this.Evaluate(iter); XPathNodeIterator xpathNodeIterator = obj as XPathNodeIterator; BaseIterator baseIterator = null; if (xpathNodeIterator != null) { baseIterator = (xpathNodeIterator as BaseIterator); if (baseIterator == null) { baseIterator = new WrapperIterator(xpathNodeIterator, iter.NamespaceManager); } return(baseIterator); } XPathNavigator xpathNavigator = obj as XPathNavigator; if (xpathNavigator != null) { XPathNodeIterator xpathNodeIterator2 = xpathNavigator.SelectChildren(XPathNodeType.All); baseIterator = (xpathNodeIterator2 as BaseIterator); if (baseIterator == null && xpathNodeIterator2 != null) { baseIterator = new WrapperIterator(xpathNodeIterator2, iter.NamespaceManager); } } if (baseIterator != null) { return(baseIterator); } if (obj == null) { return(new NullIterator(iter)); } returnType = Expression.GetReturnType(obj); break; } } throw new XPathException(string.Format("expected nodeset but was {1}: {0}", this.ToString(), returnType)); }
public IList<string> GrabBackDropUrls(XPathNavigator nav) { List<string> urls = new List<string>(); XPathNodeIterator nIter = nav.SelectChildren("backdrop", ""); if (nav.MoveToFollowing("backdrop", "")) { XPathNavigator localNav = nav.CreateNavigator(); nav.MoveToParent(); for (int i = 0; i < nIter.Count; i++) { if (localNav.GetAttribute("size", "").ToUpperInvariant().Equals("original".ToUpperInvariant())) urls.Add(localNav.Value); localNav.MoveToNext(); } } return urls; }
protected void Parse(XPathNavigator navigator) { XPathNodeIterator xpni = navigator.SelectChildren(XmlConstants.Property, XmlConstants.SchemaXMLNS); while (xpni.MoveNext()) { string propName = xpni.Current.GetAttribute(XmlConstants.Property_Name_Attribute, string.Empty); int propEditLevel = 0; Int32.TryParse(xpni.Current.GetAttribute(XmlConstants.Property_EditLevel_Attribute, string.Empty), out propEditLevel); string propOptionValues = xpni.Current.GetAttribute(XmlConstants.Property_OptionValues_Attribute, string.Empty); string propValue = xpni.Current.Value; if (!string.IsNullOrEmpty(propName) && !string.IsNullOrEmpty(propValue)) { Property p = new Property(propName, propValue, propEditLevel, propOptionValues); properties.Add(p); } } }
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { base.ParseConfiguration(configurationElement, xmlNamespaceResolver, contentType); foreach (XPathNavigator element in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (element.LocalName) { case RangeName: int range; _range = Int32.TryParse(element.InnerXml, out range) ? range : DefaultRange; break; case SplitName: int split; _split = Int32.TryParse(element.InnerXml, out split) ? split : DefaultSplit; break; } } }
protected override void ParseConfiguration(System.Xml.XPath.XPathNavigator configurationElement, System.Xml.IXmlNamespaceResolver xmlNamespaceResolver, Schema.ContentType contentType) { base.ParseConfiguration(configurationElement, xmlNamespaceResolver, contentType); foreach (XPathNavigator node in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (node.LocalName) { case VisiblePermissionCountName: int visiblePermissionCount; if (Int32.TryParse(node.InnerXml, out visiblePermissionCount)) { _visiblePermissionCount = visiblePermissionCount; } break; } } _options = PermissionType.PermissionTypes.Select(t => new ChoiceOption((t.Name).ToString(), "$ Portal, Permission_" + t.Name)).Take(VisiblePermissionCount ?? DefaultVisiblePermissionCount).ToList(); }
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { //<MinLength>0..sok</MinLength> //<MaxLength>0..sok<MaxLength> foreach (XPathNavigator element in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (element.LocalName) { case MaxLengthName: int maxLength; if (int.TryParse(element.InnerXml, out maxLength)) _maxLength = maxLength; break; case MinLengthName: int minLength; if (int.TryParse(element.InnerXml, out minLength)) _minLength = minLength; break; } } }
/// <summary> /// Devuelve el valor del primer noso hijo solicitado. /// </summary> /// <param name="navigator">Navegador del documento XML.</param> /// <param name="child">Nodo hijo solicitado.</param> /// <returns>El valor del nodo hijo solicitado.</returns> public static string GetChildValue(this XPathNavigator navigator, string child) { if (navigator == null) { throw new ArgumentNullException(nameof(navigator)); } if (child == null) { throw new ArgumentNullException(nameof(child)); } if (child == string.Empty) { throw new ArgumentException(nameof(child)); } XPathNodeIterator children = navigator.SelectChildren(child, string.Empty); children.MoveNext(); return(children.Current.Value); }
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { base.ParseConfiguration(configurationElement, xmlNamespaceResolver, contentType); foreach (XPathNavigator node in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (node.LocalName) { case TextTypeName: ParseEnumValue(node.InnerXml, ref _textType); break; case RowsName: int rows; if (int.TryParse(node.InnerXml, out rows)) _rows = rows; break; case AppendModificationsName: if (!string.IsNullOrEmpty(node.InnerXml)) _appendModifications = node.InnerXml.ToLower().CompareTo("true") == 0; break; } } }
public ExamineBackedMedia(XPathNavigator xpath) { if (xpath == null) throw new ArgumentNullException("xpath"); Name = xpath.GetAttribute("nodeName", ""); Values = new Dictionary<string, string>(); var result = xpath.SelectChildren(XPathNodeType.Element); //add the attributes e.g. id, parentId etc if (result.Current.HasAttributes) { if (result.Current.MoveToFirstAttribute()) { Values.Add(result.Current.Name, result.Current.Value); while (result.Current.MoveToNextAttribute()) { Values.Add(result.Current.Name, result.Current.Value); } result.Current.MoveToParent(); } } while (result.MoveNext()) { if (result.Current != null && !result.Current.HasAttributes) { string value = result.Current.Value; if (string.IsNullOrEmpty(value)) { if (result.Current.HasAttributes || result.Current.SelectChildren(XPathNodeType.Element).Count > 0) { value = result.Current.OuterXml; } } Values.Add(result.Current.Name, value); } } WasLoadedFromExamine = false; }
/// <summary> /// Create an instance of a Subscription by deserializing the subscription XML. /// </summary> /// <remarks> /// The returned type will be a type derived from Subscription, such as the <see cref="HealthRecordItemChangedSubscription"/> class. /// </remarks> /// <param name="subscriptionNavigator">The xml representation to deserialize.</param> /// <returns>The subscription.</returns> /// /// <exception cref="ArgumentNullException"> /// The <paramref name="subscriptionNavigator"/> parameter is <b>null</b>. /// </exception> /// /// <exception cref="ArgumentException"> /// The <paramref name="subscriptionNavigator"/> parameter XML does not contain /// a subscription node. /// </exception> /// /// <exception cref="InvalidOperationException"> /// The <paramref name="subscriptionNavigator"/> parameter XML has an unrecognized /// subscription type. /// </exception> public static Subscription Deserialize(XPathNavigator subscriptionNavigator) { Validator.ThrowIfNavigatorNull(subscriptionNavigator); // find out what kind of node we have, and go from there... Subscription subscription = null; CommonSubscriptionData commonSubscriptionData = null; foreach (XPathNavigator typeSpecificNav in subscriptionNavigator.SelectChildren(XPathNodeType.Element)) { switch (typeSpecificNav.Name) { case "record-item-changed-event": subscription = new HealthRecordItemChangedSubscription(null); subscription.ParseXml(subscriptionNavigator); break; case "common": commonSubscriptionData = new CommonSubscriptionData(); commonSubscriptionData.ParseXml(subscriptionNavigator); break; default: throw new InvalidOperationException( String.Format( CultureInfo.InvariantCulture, ResourceRetriever.GetResourceString("UnrecognizedSubscriptionType"), typeSpecificNav.Name)); } } if (subscription != null) { subscription.CommonSubscriptionData = commonSubscriptionData; } return subscription; }
private Dictionary<string, FieldDescriptor> ParseFieldElements(XPathNavigator fieldsElement, IXmlNamespaceResolver nsres) { Dictionary<string, FieldDescriptor> fieldDescriptorList = new Dictionary<string, FieldDescriptor>(); ContentType listType = ContentType.GetByName("ContentList"); foreach (XPathNavigator fieldElement in fieldsElement.SelectChildren(XPathNodeType.Element)) { FieldDescriptor fieldDescriptor = FieldDescriptor.Parse(fieldElement, nsres, listType); fieldDescriptorList.Add(fieldDescriptor.FieldName, fieldDescriptor); } return fieldDescriptorList; }
private Dictionary<string, FieldDescriptor> ParseContentTypeElement(XPathNavigator contentTypeElement, IXmlNamespaceResolver nsres) { Dictionary<string, FieldDescriptor> result = null; foreach (XPathNavigator subElement in contentTypeElement.SelectChildren(XPathNodeType.Element)) { switch (subElement.LocalName) { case "DisplayName": _displayName = subElement.Value; break; case "Description": _description = subElement.Value; break; case "Icon": _icon = subElement.Value; break; case "Fields": result = ParseFieldElements(subElement, nsres); break; case "Actions": //_actions = null; //ParseActions(subElement, nsres); Logger.WriteWarning("Ignoring obsolete Actions element in List definition: " + this.Name); break; default: throw new NotSupportedException(String.Concat("Unknown element in ContentListDefinition: ", subElement.LocalName)); } } return result; }
protected RuleWithSubRules(XPathNavigator node, object aSetId) { PopulateSubNodes(node.SelectChildren(XPathNodeType.Element), aSetId); }
public bool Load(XPathNavigator source, XmlNamespaceManager manager) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ ResourceName = source.LocalName; Namespace = source.NamespaceURI; string value; Key = source.TryGetAttribute("key", Framework.Common.SData.Namespace, out value) ? value : null; Uri = source.TryGetAttribute("uri", Framework.Common.SData.Namespace, out value) && !string.IsNullOrEmpty(value) ? new Uri(value) : null; Uuid = source.TryGetAttribute("uuid", Framework.Common.SData.Namespace, out value) && !string.IsNullOrEmpty(value) ? new Guid(value) : (Guid?) null; Descriptor = source.TryGetAttribute("descriptor", Framework.Common.SData.Namespace, out value) ? value : null; Lookup = source.TryGetAttribute("lookup", Framework.Common.SData.Namespace, out value) ? value : null; IsDeleted = source.TryGetAttribute("isDeleted", Framework.Common.SData.Namespace, out value) && !string.IsNullOrEmpty(value) ? XmlConvert.ToBoolean(value) : (bool?) null; return source.SelectChildren(XPathNodeType.Element) .Cast<XPathNavigator>() .GroupBy(item => item.LocalName) .All(group => LoadItem(group.Key, group, manager)); }
internal static ItemType InferItemType(XPathNavigator item) { string value; if (item.TryGetAttribute("nil", Framework.Common.XSI.Namespace, out value) && XmlConvert.ToBoolean(value)) { return ItemType.Property; } if (item.HasAttribute("key", Framework.Common.SData.Namespace) || item.HasAttribute("uuid", Framework.Common.SData.Namespace) || item.HasAttribute("lookup", Framework.Common.SData.Namespace) || item.HasAttribute("descriptor", Framework.Common.SData.Namespace)) { return ItemType.Object; } if (item.HasAttribute("url", Framework.Common.SData.Namespace) || item.HasAttribute("uri", Framework.Common.SData.Namespace) || item.HasAttribute("deleteMissing", Framework.Common.SData.Namespace)) { return ItemType.PayloadCollection; } if (item.IsEmptyElement) { // workaround: Older versions of the SIF generate payload collections as empty namespace-less elements return string.IsNullOrEmpty(item.NamespaceURI) ? ItemType.PayloadCollection : ItemType.Property; } var children = item.SelectChildren(XPathNodeType.Element).Cast<XPathNavigator>(); var childCount = children.Count(); if (childCount == 0) { return ItemType.Property; } if (childCount > 1 && children.Select(child => child.LocalName).Distinct().Count() == 1) { if (children.All(child => InferItemType(child) == ItemType.Object)) { return ItemType.PayloadCollection; } if (children.All(child => InferItemType(child) == ItemType.Property)) { return ItemType.SimpleCollection; } } return ItemType.Object; }
protected override void ParseConfiguration(XPathNavigator configurationElement, IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { //...xmlns="http://schemas.sensenet.com/SenseNet/ContentRepository/SearchExpression" //.... //<Configuration> // <AllowMultiple>true<AllowMultiple> // <AllowedTypes> // <Type>Folder</Type> // <Type>File</Type> // </AllowedTypes> // <SelectionRoot> // <Path>/Root/.../1</Path> // <Path>/Root/.../2</Path> // <SelectionRoot> // <Query> // <q:And> // <q:String op="StartsWith" property="Path">.</q:String> // <q:String op="NotEqual" property="Name">Restricted</q:String> // </q:And> // </Query> //</Configuration> foreach (XPathNavigator element in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (element.LocalName) { case AllowMultipleName: _allowMultiple = element.InnerXml == "true"; break; case AllowedTypesName: _allowedTypes = new List<string>(); foreach (XPathNavigator typeElement in element.SelectChildren(TypeName, element.NamespaceURI)) { string typeName = typeElement.InnerXml; _allowedTypes.Add(typeName); } break; case SelectionRootName: _selectionRoots = new List<string>(); foreach (XPathNavigator pathElement in element.SelectChildren(PathName, element.NamespaceURI)) { string path = pathElement.InnerXml; if (path != ".") { try { RepositoryPath.CheckValidPath(path); } catch (InvalidPathException e) //rethrow { throw new InvalidPathException(String.Concat("Given path is invalid in SelectionRoot element. ContentType: ", contentType.Name, ", Field name: '", this.Name, "', path: '", path, "'. Reason: ", e.Message)); } } _selectionRoots.Add(path); } break; case QueryName: var sb = new StringBuilder(); sb.Append("<SearchExpression xmlns=\"").Append(NodeQuery.XmlNamespace).Append("\">"); sb.Append(element.InnerXml); sb.Append("</SearchExpression>"); _query = NodeQuery.Parse(sb.ToString()); break; case FieldNameName: _fieldName = element.InnerXml; break; } } }
private void SelectChildrenNS (XPathNavigator nav) { nav.MoveToFirstChild (); // root XPathNodeIterator iter = nav.SelectChildren ("foo", "urn:foo"); Assert.AreEqual (2, iter.Count, "#1"); }
public static CubicGrid Load(XPathNavigator nav) { int3 Dimensions = new int3(int.Parse(nav.GetAttribute("Width", ""), CultureInfo.InvariantCulture), int.Parse(nav.GetAttribute("Height", ""), CultureInfo.InvariantCulture), int.Parse(nav.GetAttribute("Depth", ""), CultureInfo.InvariantCulture)); float[,,] Values = new float[Dimensions.Z, Dimensions.Y, Dimensions.X]; foreach (XPathNavigator nodeNav in nav.SelectChildren("Node", "")) { //try { int X = int.Parse(nodeNav.GetAttribute("X", ""), CultureInfo.InvariantCulture); int Y = int.Parse(nodeNav.GetAttribute("Y", ""), CultureInfo.InvariantCulture); int Z = int.Parse(nodeNav.GetAttribute("Z", ""), CultureInfo.InvariantCulture); float Value = float.Parse(nodeNav.GetAttribute("Value", ""), CultureInfo.InvariantCulture); Values[Z, Y, X] = Value; } //catch { } } return new CubicGrid(Values); }
/// <summary> /// Add the excluded minify paths from the configSection /// </summary> /// <param name="node"></param> private void LoadMinifyExcludedPaths(XPathNavigator node) { HttpContext context = HttpContext.Current; if (context == null || node == null) return; string currentPath = Util.GetCurrentPath(context); XPathNodeIterator childrens = node.SelectChildren(XPathNodeType.All); foreach (XPathNavigator child in childrens) { if (!string.IsNullOrEmpty(child.GetAttribute("key", string.Empty))) { string relativePath = child.GetAttribute("key", string.Empty); string absoluteFile; if (relativePath[0].Equals('~')) { absoluteFile = context.Server.MapPath(relativePath); } else { absoluteFile = context.Server.MapPath(currentPath + relativePath); } _minifyExcludePaths.Add(absoluteFile, true); } } }
/// <summary> /// Add the excluded post params values from the configSection /// </summary> /// <param name="node"></param> private void LoadExcludedPostParamValues(XPathNavigator node) { if (node == null) return; XPathNodeIterator childrens = node.SelectChildren(XPathNodeType.All); foreach (XPathNavigator child in childrens) { if (!string.IsNullOrEmpty(child.GetAttribute("key", string.Empty))) _postParamsExcludeValues.Add(child.GetAttribute("key", string.Empty)); } }
protected override void ParseConfiguration(System.Xml.XPath.XPathNavigator configurationElement, System.Xml.IXmlNamespaceResolver xmlNamespaceResolver, ContentType contentType) { base.ParseConfiguration(configurationElement, xmlNamespaceResolver, contentType); //<Enabled>true|false</Enabled> //<AdminEmail>[email protected]</AdminEmail> //<RequireUniqueEmail>true|false</RequireUniqueEmail> //<MailDefinition>...</MailDefinition> //<IsBodyHtml>true|false</IsBodyHtml> //<MailSubject>...</MailSubject> //<MailPriority>Low|Normal|High</MailPriority> //<MailFrom>[email protected]</MailFrom> foreach (XPathNavigator node in configurationElement.SelectChildren(XPathNodeType.Element)) { switch (node.LocalName) { case EnabledName: bool enabled; if (Boolean.TryParse(node.InnerXml, out enabled)) { _enabled = enabled; } break; case AdminEmailName: _adminEmail = node.InnerXml; break; case RequireUniqueEmailName: bool requireUniqueEmail; if (Boolean.TryParse(node.InnerXml, out requireUniqueEmail)) { _requireUniqueEmail = requireUniqueEmail; } break; case MailDefinitionName: _mailDefinition = node.InnerXml; break; case IsBodyHtmlName: bool isBodyHtml; if (Boolean.TryParse(node.InnerXml, out isBodyHtml)) { _isBodyHtml = isBodyHtml; } break; case MailSubjectName: _mailSubject = node.InnerXml; break; case MailPriorityName: if (node.InnerXml == Enum.GetName(typeof(MailPriority), MailPriority.Low)) { _mailPriority = MailPriority.Low; } else if (node.InnerXml == Enum.GetName(typeof(MailPriority), MailPriority.Normal)) { _mailPriority = MailPriority.Normal; } else if (node.InnerXml == Enum.GetName(typeof(MailPriority), MailPriority.High)) { _mailPriority = MailPriority.High; } else { _mailPriority = MailPriority.Normal; } break; case MailFromName: _mailFrom = node.InnerXml; break; } } }