public TypesBuilder(XElement element) { Types = new HashSet<Type>(); XAttribute typeAttribute = element.Attribute("type"); if (typeAttribute == null) { Types.Add(new Type { TypeKind = TypeKind.Text }); return; } IEnumerable<XElement> targets = element.Descendants(Constants.TCM_NAMESPACE + "TargetSchema"); if (targets.Count() > 0) { TypeKind typeKind = Util.Parse(element.Descendants(Constants.TCM_NAMESPACE + "linktype").First().Value); foreach (XElement target in targets) { Types.Add(new Type { Name = target.Attribute(Constants.XLINK_NAMESPACE + "title").Value, TypeKind = typeKind }); } return; } XElement embedded = element.Descendants(Constants.TCM_NAMESPACE + "EmbeddedSchema").FirstOrDefault(); if (embedded != null) { Types.Add(new Type { Name = embedded.Attribute(Constants.XLINK_NAMESPACE + "title").Value, TypeKind = TypeKind.Embedded }); return; } Types.Add(new Type { TypeKind = Util.Parse(typeAttribute.Value) }); }
public UpdateInfo(XElement element) { XElement versionElement = element.Descendants().First(); XElement urlElement = element.Descendants().Last(); Version = new Version(versionElement.Value); Url = urlElement.Value; }
/// <summary> /// Recovers the "after" SrcML from a SrcDiff representation. /// </summary> /// <param name="xml">The root element of the SrcDiff XML to filter.</param> /// <returns>A copy of the input XML, with the diff elements removed, representing the modified file.</returns> public static XElement GetAfterVersion(XElement xml) { if(xml == null) { throw new ArgumentNullException("xml"); } var root = new XElement(xml); //trim any nodes that were deleted (but keeping any common elements that might be within) foreach(var deleteElement in root.Descendants(DIFF.Delete).ToList()) { var commonElements = deleteElement.Descendants(DIFF.Common).ToList(); if(commonElements.Count > 0) { deleteElement.ReplaceWith(commonElements.SelectMany(ce => ce.Nodes()).ToList()); } else { deleteElement.Remove(); } } //add the nodes that were added foreach(var addElement in root.Descendants(DIFF.Insert).ToList()) { addElement.ReplaceWith(addElement.Nodes()); } //remove the diff tags from any remaining common elements foreach(var commonElement in root.Descendants(DIFF.Common).ToList()) { commonElement.ReplaceWith(commonElement.Nodes()); } return root; }
public water_base(XElement xml) : base(xml) { var diff = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "DiffuseColour").FirstOrDefault(); var nor1 = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Normal_Map").FirstOrDefault(); var spec = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Spec_Map").FirstOrDefault(); var nor2 = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Normal_Map2").FirstOrDefault(); var foam = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Foam_Map").FirstOrDefault(); var cube = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "EnvironmentCube").FirstOrDefault(); if (diff != null) { diffuse = diff.Attribute("FileName").Value; } if (nor1 != null) { normal = nor1.Attribute("FileName").Value; } if (spec != null) { specular = spec.Attribute("FileName").Value; } if (nor2 != null) { normal2 = nor2.Attribute("FileName").Value; } if (foam != null) { foamMap = foam.Attribute("FileName").Value; } if (cube != null) { cubeMap = cube.Attribute("FileName").Value; } var mind = xml.Descendants("Constant").Where(e => e.Attribute("Alias").Value == "Min_distance").FirstOrDefault(); var maxd = xml.Descendants("Constant").Where(e => e.Attribute("Alias").Value == "Max_distance").FirstOrDefault(); var seaf = xml.Descendants("Constant").Where(e => e.Attribute("Alias").Value == "Sea_Falloff").FirstOrDefault(); var shor = xml.Descendants("Constant").Where(e => e.Attribute("Alias").Value == "shore_factor").FirstOrDefault(); if (mind != null) { minDistance = ReadConstant(mind); } if (maxd != null) { maxDistance = ReadConstant(maxd); } if (seaf != null) { seaFalloff = ReadConstant(seaf); } if (shor != null) { shoreFactor = ReadConstant(shor); } }
public FailureExpression(XElement expressionNode) { Location = SourceLocation.FromXElement(expressionNode); var exprTypeAttr = expressionNode.Attribute("type"); if (exprTypeAttr != null) { ExpressionType = exprTypeAttr.Value.Trim(); } var originalNode = expressionNode.Descendants("Original").FirstOrDefault(); if (originalNode != null) { OriginalExpression = originalNode.Value.Trim(); } var expandedNode = expressionNode.Descendants("Expanded").FirstOrDefault(); if (expandedNode != null) { ExpandedExpression = expandedNode.Value.Trim(); } var ExceptionNode = expressionNode.Descendants("Exception").FirstOrDefault(); if (ExceptionNode != null) { ExceptionMessage = ExceptionNode.Value.Trim(); } }
private void GetValue(Dictionary<string, TmpTestNodeMethod> resultDictionary, XElement test) { try { var result = new TmpTestNodeMethod(test.Attribute("name").Value); result.State = Switch.Into<TestNodeState>() .From(test.Attribute("result").Value) .Case("Pass", TestNodeState.Success) .Case("Skip", TestNodeState.Inactive) .Case("Fail", TestNodeState.Failure) .Default(TestNodeState.Inconclusive); if (result.State != TestNodeState.Success) { result.Message = test.Descendants(XName.Get("message", "")) .Select(d => d.Value).MaySingle().Else(""); result.StackTrace = test.Descendants(XName.Get("stack-trace", "")).Select(d => d.Value).MaySingle().Else(""); result.Message = result.Message + "\n" + result.StackTrace; } resultDictionary.Add(result.Name, result); } catch (Exception e) { _log.Error("Log file parsing error", e); } }
public static Playlist Deserialize(XElement xml) { Playlist playlist = null; Guid id; var idElement = xml.Descendants("Id").FirstOrDefault(); var nameElement = xml.Descendants("Name").FirstOrDefault(); var tracksElement = xml.Descendants("Tracks").FirstOrDefault(); if (null != nameElement && null != idElement && Guid.TryParse(idElement.Value, out id) && null != tracksElement) { playlist = new Playlist() { Name = nameElement.Value, Id = id }; foreach(var trackElement in tracksElement.Descendants("Track")) { playlist.Tracks.Add(Track.Deserialize(trackElement)); } } else { Debug.WriteLine("Playlist: Invalid track XML"); } return playlist; }
/// <summary> /// The method for creating a trigger /// </summary> /// <param name="_trigger">The xml element containing the trigger description (Root node = Trigger)</param> /// <returns>The newly created trigger.</returns> public override Trigger CreateTrigger(XElement _trigger) { String id = _trigger.Attribute("id").Value; String question = _trigger.Descendants("Question").First().Value; String answer = _trigger.Descendants("Answer").First().Value; QuestionAnswerTrigger t = new QuestionAnswerTrigger(id, question, answer); t.preTriggerObjectIds = new List<string>(); t.postTriggerObjectIds = new List<string>(); if (_trigger.Element("PreTriggerObject") != null) foreach (XElement objectIdElement in _trigger.Element("PreTriggerObject").Elements()) { t.preTriggerObjectIds.Add(objectIdElement.Value); } if (_trigger.Element("PostTriggerObject") != null) foreach (XElement objectIdElement in _trigger.Element("PostTriggerObject").Elements()) { t.postTriggerObjectIds.Add(objectIdElement.Value); } return t; }
public override void FromXml(XElement artistBaseXml) { // ReSharper disable PossibleNullReferenceException string uriString; if (artistBaseXml.Descendants("image") .FirstOrDefault(x =>x.Attribute("size").Value == "medium") != null) { uriString = artistBaseXml.Descendants("image") .FirstOrDefault(x => x.Attribute("size").Value == "medium") .Value; } else { uriString = artistBaseXml.Descendants("image") .FirstOrDefault() .Value; } BitmapImage img = null; if (!string.IsNullOrEmpty(uriString)) img = new BitmapImage(new Uri(uriString)); Name = artistBaseXml.Element("name").Value; MusicBrainzId = artistBaseXml.Element("mbid").Value; if (artistBaseXml.Element("match") == null || string.IsNullOrEmpty(artistBaseXml.Element("match").Value)) SimilarMatch = 0; else SimilarMatch = (int) Math.Round(Convert.ToDouble(artistBaseXml.Element("match").Value), 0); Url = new Uri(artistBaseXml.Element("url").Value, UriKind.RelativeOrAbsolute); if (img != null) PictureSmall = img; // ReSharper restore PossibleNullReferenceException }
public ReportRow(XElement xml, IEnumerable<ReportColumnDescription> columnDescriptions) { _columnDescriptions = columnDescriptions; Type = xml.Name.ToString(); RowType = ""; RowValue = ""; if (xml.Name == "TextRow") { if (xml.Attribute("value") != null) RowValue = xml.Attribute("value").Value; Columns = new List<ReportColumn>(); } else { var rowData = xml.Descendants("RowData").FirstOrDefault(); if (rowData != null) { RowType = rowData.Attribute("rowType").Value; RowValue = rowData.Attribute("value").Value; } var columns = new List<ReportColumn>(); foreach (var columnXML in xml.Descendants("ColData")) columns.Add(new ReportColumn(columnXML)); Columns = columns; } }
//===================================================================== /// <summary> /// Constructor /// </summary> /// <param name="currentConfig">The current XML configuration XML fragment</param> public ESentResolveReferenceLinksConfigDlg(string currentConfig) { XElement node; InitializeComponent(); lnkProjectSite.Links[0].LinkData = "https://GitHub.com/EWSoftware/SHFB"; // Load the current settings. Note that there are multiple configurations (one for each help file // format). However, the settings will be the same across all of them. config = XElement.Parse(currentConfig); node = config.Descendants("msdnContentIdCache").First(); txtContentIdCachePath.Text = node.Attribute("cachePath").Value; udcContentIdLocalCacheSize.Value = ((int?)node.Attribute("localCacheSize") ?? 2500); node = config.Descendants("targets").First(d => d.Attribute("id").Value == "FrameworkTargets"); txtFrameworkTargetsCachePath.Text = node.Attribute("cachePath").Value; udcFrameworkTargetsLocalCacheSize.Value = ((int?)node.Attribute("localCacheSize") ?? 2500); node = config.Descendants("targets").First(d => d.Attribute("id").Value == "ProjectTargets"); txtProjectTargetsCachePath.Text = (string)node.Attribute("cachePath"); udcProjectTargetsLocalCacheSize.Value = ((int?)node.Attribute("localCacheSize") ?? 2500); chkEnableLocalCache.Checked = !String.IsNullOrWhiteSpace(txtProjectTargetsCachePath.Text); }
public List<Error> Validate(XElement doc) { XNamespace ns = "http://www.wfmc.org/2008/XPDL2.1"; var activities = from intermediateEvent in doc.Descendants(ns + "IntermediateEvent") let triggerResultMessageElement = intermediateEvent.Element(ns + "TriggerResultMessage") let triggerAttribute = intermediateEvent.Attribute("Trigger") let catchThrowAttribute = triggerResultMessageElement.Attribute("CatchThrow") let eventElement = intermediateEvent.Parent where triggerResultMessageElement != null && triggerAttribute != null && catchThrowAttribute != null && catchThrowAttribute.Value == "THROW" && triggerAttribute.Value == "Message" && eventElement != null select eventElement.Parent; return (from activity in activities let activityId = activity.Attribute("Id").Value let messageFlows = (from messageFlow in doc.Descendants(ns + "MessageFlow") where messageFlow.Attribute("Source").Value == activityId select messageFlow) where !messageFlows.Any() select new Error { ElementId = Guid.Parse(activityId), ElementName = activity.Attribute("Name").Value, ElementXpath = activity.GetAbsoluteXPath(), Message = "El elemento viola la regla Style 0123" }).ToList(); }
public override bool Parse(XElement xmlElement) { var parseOK = false; if (base.Parse(xmlElement)) { var attributes = xmlElement.Attributes(); var portable = (from attr in attributes where attr.Name == "Portable" select attr.Value).FirstOrDefault(); CommandLine = (from element in xmlElement.Descendants() where element.Name == "CommandLine" select element.Value).FirstOrDefault(); UpdateURL = (from element in xmlElement.Descendants() where element.Name == "UpdateURL" select element.Value).FirstOrDefault(); CanUpdate = !string.IsNullOrEmpty(UpdateURL) && !string.IsNullOrWhiteSpace(UpdateURL); bool isPortable; IsPortable = bool.TryParse(portable, out isPortable) ? isPortable : true; // portable by default? var properties = from element in xmlElement.Descendants() where element.Name == "Property" select element; foreach (var prop in properties) { attributes = prop.Attributes(); var propName = (from attr in attributes where attr.Name == "Name" select attr.Value).FirstOrDefault(); var propValue = (from attr in attributes where attr.Name == "Value" select attr.Value).FirstOrDefault(); if (string.IsNullOrEmpty(propName) || string.IsNullOrEmpty(propValue)) { continue; } Properties.Add(propName, propValue); } parseOK = true; } return parseOK; }
private static IExerciseDefinition GetExercise(XElement exerciseXml, IDictionary<string, IConstraint> allConstraints) { var exercise = new ExerciseDefinition(exerciseXml.Attribute("name").Value, new ExerciseTemplate(exerciseXml.Attribute("template").Value)); var numbersXml = from n in exerciseXml.Descendants("numbers").First().Descendants("number") select n; foreach (var number in numbersXml) { var minValue = int.Parse(number.Attribute("minvalue").Value); var maxValue = int.Parse(number.Attribute("maxvalue").Value); var decimals = int.Parse(number.Attribute("decimals").Value); exercise.AddNumberDefinition(new NumberDefinition("", minValue, maxValue, decimals)); } var constraintsRoot = exerciseXml.Descendants("constraints").FirstOrDefault(); if (constraintsRoot != null) { var constraintsXml = from c in constraintsRoot.Descendants("constraint") select c; foreach (var constraint in constraintsXml) { var constraintName = constraint.Attribute("type").Value; exercise.AddConstraint(allConstraints[constraintName]); } } return exercise; }
private Polygon ParsePolygon(string name, XElement pg, string ns, bool onlyOuter) { PolygonReader polyReader = new PolygonReader(); var outerBoundary = pg.Descendants(XName.Get("outerBoundaryIs", ns)).FirstOrDefault(); var innerPolygons = pg.Descendants(XName.Get("innerBoundaryIs", ns)).ToList(); if (outerBoundary == null) { //check if the linear ring has been added without outer/inner boundaries var linearRing = pg.Descendants(XName.Get("LinearRing", ns)).FirstOrDefault(); if (linearRing != null) { return polyReader.FromPointList(name, linearRing.Descendants(XName.Get("coordinates", ns)).First().Value); } return null; } Polygon p = polyReader.FromPointList(name, outerBoundary.Descendants(XName.Get("coordinates", ns)).First().Value); if (!onlyOuter) { foreach (var innerPolygon in innerPolygons) { var linearRings = innerPolygon.Descendants(XName.Get("LinearRing", ns)).ToList(); foreach (var ring in linearRings) { p.InnerPolygons.Add(polyReader.FromPointList(name, ring.Descendants(XName.Get("coordinates", ns)).First().Value)); } } } return p; }
public glass_base(XElement xml) : base(xml) { coreDefaults = new glass_base { Translucent = Troolean.True, DoubleSided = Troolean.False, FogEnabled = Troolean.True, NeedsWorldSpaceVertexNormal = Troolean.True, NeedsWorldEyePos = Troolean.True, NeedsWorldVertexPos = Troolean.True, //NEEDS_TANGENT_FRAME = 1, //NEEDS_PER_PIXEL_SPECULAR_LIGHTING = 1, NeedsLocalCubeMap = Troolean.True, //NEEDS_SPECULAR_MASK = 1, ReceivesShadows = Troolean.True, //IS_THIN_GLASS = 1, TextureCoordSources = { new TextureCoordSource { Alias = "Tex0", UVStream = 0 } }, Samplers = { new Sampler { Alias = "SAMPLER_DiffuseColour", UsageRGB = Sampler.Usage.DiffuseAlbedo, sRGBRead = true }, new Sampler { Alias = "SAMPLER_NormalMap", UsageRGB = Sampler.Usage.TangentSpaceNormals }, new Sampler { Alias = "SAMPLER_SpecMap", UsageRGB = Sampler.Usage.SpecColour, UsageAlpha = Sampler.Usage.SpecPower } } }; var diff = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "DiffuseColour").FirstOrDefault(); var norm = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Normal_Map").FirstOrDefault(); var spec = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Spec_Map").FirstOrDefault(); var cube = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "EnvironmentCube").FirstOrDefault(); if (diff != null) { diffuse = diff.Attribute("FileName").Value; } if (norm != null) { normal = norm.Attribute("FileName").Value; } if (spec != null) { specular = spec.Attribute("FileName").Value; } if (cube != null) { cubeMap = cube.Attribute("FileName").Value; } }
public override void FromXml(XElement albumXml) { // ReSharper disable PossibleNullReferenceException Name = albumXml.Element("name").Value; if (albumXml.Element("artist") != null) { ArtistName = albumXml.Element("artist").HasElements ? albumXml.Element("artist").Element("name").Value : albumXml.Element("artist").Value; } MusicBrainzId = albumXml.Element("mbid").Value; Url = new Uri(albumXml.Element("url").Value, UriKind.RelativeOrAbsolute); if (albumXml.Element("releasedate") != null && !string.IsNullOrEmpty(albumXml.Element("releasedate").Value)) ReleaseDate = Convert.ToDateTime(albumXml.Element("releasedate").Value); string uriString = albumXml.Descendants("image") .First(descendant => descendant.Attribute("size").Value == "medium") .Value; if (!string.IsNullOrEmpty(uriString)) Picture = new BitmapImage(new Uri(uriString)); uriString = albumXml.Descendants("image") .First(descendant => descendant.Attribute("size").Value == "small") .Value; if (!string.IsNullOrEmpty(uriString)) PictureSmall = new BitmapImage(new Uri(uriString)); uriString = albumXml.Descendants("image") .LastOrDefault() .Value; if (!string.IsNullOrEmpty(uriString)) PictureLarge = new BitmapImage(new Uri(uriString)); Listeners = albumXml.Element("listeners") == null ? 0 : Convert.ToInt32(albumXml.Element("listeners").Value); PlayCount = albumXml.Element("playcount") == null ? 0 : Convert.ToInt32(albumXml.Element("playcount").Value); Wiki = new Biography(albumXml.Descendants("wiki").FirstOrDefault()); var tags = albumXml.Descendants("tag"); Tags = new List<Tag>(tags.Count()); foreach (var tag in tags) Tags.Add(new Tag(tag)); var tracks = albumXml.Descendants("track"); Tracks = new List<Track>(tracks.Count()); foreach (var track in tracks) Tracks.Add(new Track(track)); // ReSharper restore PossibleNullReferenceException }
private StackFrameFilterDefinition GenerateDefinition(XElement element) { var definition = new StackFrameFilterDefinition(); definition.Order = int.Parse(element.Descendants().First(x => x.Name.LocalName == "Order").Value); definition.FilterType = ConvertToFilterType(element.Descendants().First(x => x.Name.LocalName == "Type").Value); definition.RegexFilterPattern = element.Descendants().First(x => x.Name.LocalName == "RegexPattern").Value; return definition; }
public simple_spec_base(XElement xml) : base(xml) { var diff = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "DiffuseColour").FirstOrDefault(); var spec = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Spec_Map").FirstOrDefault(); if (diff != null) { diffuse = diff.Attribute("FileName").Value; } if (spec != null) { specular = spec.Attribute("FileName").Value; } }
public static IBucket FromXml(XElement element, SharpGsClient connector) { var bucket = new Bucket(connector) { Name = element.Descendants("Name").First().Value, CreationDate = DateTime.Parse(element.Descendants("CreationDate").First().Value) }; return bucket; }
private static ChangeLogVersionDetails BuildChangeLogVersionDetails(XElement changeVersion) { var name = changeVersion.Attribute("Name").Value; var features = changeVersion.Descendants("Feature").Select(item => item.Value).ToList(); var bugs = changeVersion.Descendants("Bug").Select(item => item.Value).ToList(); var others = changeVersion.Descendants("Other").Select(item => item.Value).ToList(); return new ChangeLogVersionDetails(name, features, bugs, others); }
public static IOwner FromXml(XElement element, SharpGsClient connector) { if (element == null) return null; var owner = new Owner(connector); owner.ID = element.Descendants("ID").Select(o => o.Value).FirstOrDefault(); owner.DisplayName = element.Descendants("DisplayName").Select(o => o.Value).FirstOrDefault(); return owner; }
public XsdFileGenerator() { this.template = LoadTemplateXSD(); this.filtersGoHere = template.Descendants("filters-go-here").Single(); this.typesGoHere = template.Descendants("types-go-here").Single(); this.typesEmitted = new HashSet<string>(); }
public decal_base(XElement xml) : base(xml) { var diff = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "DiffuseColour").FirstOrDefault(); var tile = xml.Descendants("Constant").Where(e => e.Attribute("Alias").Value == "TileSize").FirstOrDefault(); if (diff != null) { diffuse = diff.Attribute("FileName").Value; } if (tile != null) { tileSize = ReadConstant(tile); } }
public object Deserialize(XElement xml, Type targetType, bool elementNameMayContainTargetTypeName) { //# check NULL attribute var null_attrib = xml.Attribute(Options.NullValueAttributeName); if (null_attrib != null && null_attrib.Value != null && null_attrib.Value.ToLower() == "true") { return null; } //# check if has only one child with NULL attribute (i.e. wrapped element signifies null) if(xml.Descendants().Count() == 1) { var nullElementCandidate = xml.Descendants().Single(); null_attrib = nullElementCandidate.Attribute(Options.NullValueAttributeName); if (null_attrib != null && null_attrib.Value != null && null_attrib.Value.ToLower() == "true") { return null; } } //# try to derive member type from element name var suggestedMemberTypeName = xml.Name.LocalName; if (elementNameMayContainTargetTypeName && !string.Equals(suggestedMemberTypeName, targetType.Name)) { //# try to find type with suggested name var typeCandidate = (Type)null; //# first look in KnownTypes map typeCandidate = TypeResolver.ResolveTypes( candidates: KnownTypes.GetValues(XName.Get(suggestedMemberTypeName)).EmptyIfNull(), baseTypes: new Type[] { targetType }).FirstOrDefault(); //# then try to find in loaded assemblies (slower than lookup) if (typeCandidate == null) { typeCandidate = TypeResolver.ResolveType( suggestedMemberTypeName, ignoreCase: true, baseTypes: new Type[] { targetType }); } if (typeCandidate != null) { targetType = typeCandidate; } } var strategy = (IFlexiXmlTypeSerializationStrategy) GetTypeSerializationStrategy(targetType); return strategy.Deserialize(xml, targetType, this); }
protected override IEnumerable<ActionConfiguration> Parse(XElement gooseConfigRootNode) { var workingDirectory = gooseConfigRootNode.Descendants("build-directory").SingleOrDefault(); var command = gooseConfigRootNode.Descendants("compile-command").SingleOrDefault(); return new[] { this.CreateCommandConfiguration( trigger: "save", glob: "*.less", workingDirectory : workingDirectory == null ? null : workingDirectory.Value, command: command == null ? null : command.Value)}; }
public override void Initialize(XElement configRoot) { var connectionStringElem = configRoot.Descendants("ConnectionString").FirstOrDefault(); if (connectionStringElem == null) throw new Exception("Missing 'ConnectionString' element."); _connectionString = connectionStringElem.Value; var locationStringElem = configRoot.Descendants("BaseLocation").FirstOrDefault(); if (locationStringElem == null) throw new Exception("Missing 'BaseLocation' element."); _baseLocation = locationStringElem.Value; }
public TextReplaceElement (XElement XmlTextReplaceElement) { if (XmlTextReplaceElement == null) { From = "NeuFrom"; To = "NeuTo"; return; } From = XmlTextReplaceElement.Descendants("From").First().Value; To = XmlTextReplaceElement.Descendants("To").First().Value; }
public car_shader_base(XElement xml) : base(xml) { var norm = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Normal_Map").FirstOrDefault(); var deca = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Decals").FirstOrDefault(); var decs = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "DecalsSpec").FirstOrDefault(); if (norm != null) { normal = norm.Attribute("FileName").Value; } if (deca != null) { decal = deca.Attribute("FileName").Value; } if (decs != null) { decalSpec = decs.Attribute("FileName").Value; } }
public vertex_norm_spec_env_base(XElement xml) : base(xml) { var diff = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "DiffuseColour").FirstOrDefault(); var norm = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Normal_Map").FirstOrDefault(); var spec = xml.Descendants("Texture").Where(e => e.Attribute("Alias").Value == "Spec_Map").FirstOrDefault(); if (diff != null) { diffuse = diff.Attribute("FileName").Value; } if (norm != null) { normal = norm.Attribute("FileName").Value; } if (spec != null) { specular = spec.Attribute("FileName").Value; } }
/// <summary> /// xmlのファイルパスから読み込む場合。 /// </summary> private void LoadFromPath( string i_path ) { try { System.Xml.Linq.XDocument xml = System.Xml.Linq.XDocument.Load( i_path ); System.Xml.Linq.XElement root = xml.Root; // xmlデータをログに表示するよ。 ShowData( root ); // 名前を指定して検索する場合は、この関数を使おう! var titles = root.Descendants( "title" ); if( titles != null ) { foreach( var title in titles ) { string nameText = title.Name.LocalName; string valueText = title.Value; Debug.LogFormat( "name:{0}, value:{1}", nameText, valueText ); } } } catch( System.Exception i_exception ) { Debug.LogErrorFormat( "うーむ、このXML情報は読み込めなかったらしい。エラーの詳細を添付しておくよ。{0}", i_exception ); } }
protected override SendResult ParseResponseImp(System.Xml.Linq.XElement xml) { if (null != xml.Descendants("Mute").FirstOrDefault()) { return(SendResult.Succcess); } else { return(SendResult.Empty); } }
public void RemoveFromXml(System.Xml.Linq.XElement option) { var result = option.Descendants(key).ToArray(); if (result.Count() > 0) { foreach (var item in result) { item.Remove(); } } }
public void Deserialize(System.Xml.Linq.XElement node, XmlDeserializeContext context) { IEnumerable <XElement> nodes = node.Descendants("pvDesp"); foreach (XElement item in nodes) { PropertyValidatorDescriptor pvDesp = new PropertyValidatorDescriptor(); pvDesp.Deserialize(item, context); this.Add(pvDesp); } }
public static void LoadFromXml(this Dictionary <string, List <string> > dic, System.Xml.Linq.XElement option, string nodeName, ref string pattern) { dic.Clear(); if (option.Element(nodeName) == null && option.Element("ClassificationSet") != null) { nodeName = "ClassificationSet"; } var result = (from item in option.Descendants(nodeName) select item).FirstOrDefault(); if (null == result) { return; } if (result.Element("Pattern") == null) { pattern = "(.*)"; } else { pattern = result.Element("Pattern").Value; } if (result.Element("ClassificationItem") == null) { foreach (var node in result.Descendants("Set")) { var lst = new List <string>(); dic[node.Attribute("Key").Value] = lst; foreach (var subNode in node.Descendants("Value")) { lst.Add(subNode.Value); } } } else { foreach (var node in result.Descendants("ClassificationItem")) { var lst = new List <string>(); dic[node.Element("classifiedName").Value] = lst; foreach (var subNode in node.Descendants("experimentName")) { lst.Add(subNode.Value); } } } }
//TODO: add a link for Trinity Configuration File Format Specification v1. /// <summary> /// Constructs a new configuration entry from an XML element. /// </summary> /// <param name="entry">The XML element.</param> public ConfigurationEntry(System.Xml.Linq.XElement entry) : this(entry.Name.LocalName) { foreach (var attribute in entry.Attributes()) { m_settings.Add(attribute.Name.LocalName, new ConfigurationSetting(attribute)); } foreach (var child in entry.Descendants()) { m_children.Add(new ConfigurationEntry(child)); } }
private void readXML(string filename) { // Create and load the XML document. // XmlDocument doc = new XmlDocument(); // doc.Load("xTree.xml"); // Create an XmlNodeReader using the XML document. //XmlNodeReader nodeReader = new XmlNodeReader(doc); // Set the validation settings on the XmlReaderSettings object. XmlReaderSettings settings = new XmlReaderSettings(); settings.ValidationType = ValidationType.Schema; settings.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack); xTree = new XElement("root", ""); // Parse the XML file. try{ xTree = XElement.Load(filename); } catch (Exception evt) { this.toolStripStatusLabel1.Text = evt.Message + "\nenthält keine XML Daten"; return; } keineEingaben(); // alle Leave-Handler und hscrollbar deaktivieren this.toolStripStatusLabel1.Text = " xTree gelesen"; sortEtappen(); XElement lastelem = xTree.Descendants("etappe").Last(); strID = lastelem.Element("ID").Value; lastID = strID; XElement firstelem = xTree.Descendants().First(); strID = firstelem.Element("ID").Value; tbID.Text = strID; int i = int.Parse(strID); hScrollBar1.Value = i; btFirst_Click(null, null); alleEingaben(); // alle Leave-Handler und hscrollbar setzen }
protected override void LoadAttributes(System.Xml.Linq.XElement element) { if (!element.Name.LocalName.Equals("text", StringComparison.InvariantCulture)) { throw new InvalidOperationException("'text' element expected."); } //this.Text = element.Attribute("text").Value; var textElement = element.Descendants("text").FirstOrDefault(); if (textElement != null) { this.Text = textElement.Value; } if (element.Attribute("color") != null) { this.Color = (Color)ColorConverter.ConvertFromString(element.Attribute("color").Value); } }
private bool etappeExist(XElement etappe) { // input would be your edited XML, this is just sample data to illustrate string thisID = etappe.Element("ID").Value; if (thisID != null && thisID != "") { itemsID = from record in xTree.Descendants("etappe") where record.Element("ID").Value.Equals(thisID) select record; int rWert = itemsID.Elements().Count(); if (rWert > 0) { return(true); } } return(false); }
public override bool ParseDefinition(System.Xml.Linq.XElement element) { bool result = base.ParseDefinition(element); // parsing of the namedValue var ListOfNamedValues = element.Descendants("NamedValue"); foreach (var namedValueDefinition in ListOfNamedValues) { //create the NamedValue container int namedValuePosition = int.Parse(namedValueDefinition.Attribute("Position").Value); OptionContainer opsContainer = new OptionContainer(); opsContainer.Name = namedValueDefinition.Attribute("Name").Value; opsContainer.Position = namedValuePosition; // check for the length, if its '*' then set the max int else parse it if (namedValueDefinition.Attribute("Length").Value == "*") { opsContainer.Length = int.MaxValue; } else { opsContainer.Length = int.Parse(namedValueDefinition.Attribute("Length").Value); } //fill up the created container var listOfOptions = namedValueDefinition.Descendants("Options"); foreach (var option in listOfOptions) { opsContainer.insertOption(option.Value, option.Attribute("Name").Value); } // add the container to array of options ArrayOfOptions.Add(opsContainer.Position, opsContainer); } return(result); }
internal static string getNodeAttribute(System.Xml.Linq.XElement xmlNode, string nodeName, string attributeName) { return(xmlNode.Descendants(nodeName).FirstOrDefault() == null ? "" : xmlNode.Descendants(nodeName).FirstOrDefault().Attribute(attributeName).Value); }
/// <summary> /// Gets the first descendant node with the given name. /// This is necessary for the node retrieval because the various namespaces in feeds. /// </summary> /// <param name="parentNode">The parent node.</param> /// <param name="nodeName">The name of the selected descendant node.</param> public static XElement GetDescendantNodeByName(this XElement parentNode, string nodeName) { return(parentNode.Descendants().FirstOrDefault(node => node.Name.LocalName == nodeName)); }
public static string getSqlHTML(string sql, DMClient dmc) { string retValue = null; bool compressed = ((dmc.origUrl.Contains(".php") && dmc.origUrl.Contains("cc1")) || dmc.origUrl.ToLower().Contains("postgres")) ? false : true; QTIUtility.RequesterAsync rr = new QTIUtility.RequesterAsync(sql, dmc.origUrl, dmc.token, compressed); DataTable dt = rr.execute(); if (dt.Columns.Contains("qdecode") || dt.Columns.Contains("QDECODE")) { foreach (DataRow dr in dt.Rows) { string data = QTIUtility.BbQuery.getStringFromData(dr["qdecode"].ToString()); System.Xml.Linq.XElement qd = System.Xml.Linq.XElement.Parse(data); var qs = qd.Descendants(XName.Get("mat_formattedtext")); if (qs.Count() > 0) { dr["qdecode"] = QTIUtility.Utilities.StripTags(qs.FirstOrDefault().Value); } } } if (dt.Columns.Contains("qrscore") || dt.Columns.Contains("QRSCORE")) { foreach (DataRow dr in dt.Rows) { string data = QTIUtility.BbQuery.getStringFromData(dr["qrscore"].ToString()); System.Xml.Linq.XElement qd = System.Xml.Linq.XElement.Parse(data); string sc = ""; var qs = qd.Descendants(XName.Get("score_value")); if (qs.Count() > 0) { foreach (string v in qs) { sc += ":" + v; } } qs = qd.Descendants(XName.Get("score_maximum")); if (qs.Count() > 0) { foreach (string v in qs) { sc += ":" + v; } } dr["qrscore"] = sc.Substring(1); } } StringBuilder sb = new StringBuilder("<table style=\"font-family: Tahoma, Arial, sans-serif;font-size:12px\" >"); sb.Append("<tr>"); if (dt != null && dt.Rows.Count > 0) { foreach (DataColumn dc in dt.Columns) { sb.Append("<th>" + dc.ColumnName + "</th>"); } sb.Append("</tr>"); foreach (DataRow dr in dt.Rows) { sb.Append("<tr>"); foreach (DataColumn dc in dt.Columns) { sb.Append("<td>" + dr[dc].ToString() + "</td>"); } sb.Append("</tr>"); } sb.Append("</table>"); } retValue = sb.ToString(); return(retValue); }
internal static string getNodeValueByAttribute(System.Xml.Linq.XElement xmlNode, string nodeName, string attributeName, string attributeNameValue) { return((from x in xmlNode.Descendants(nodeName) where x.Attribute(attributeName).Value == attributeNameValue select x.Value).FirstOrDefault()); }
internal void WriteFixedWidth(System.Xml.Linq.XElement CommandNode, DataTable Table, string outputStrmFilePath) { try { int StartAt = CommandNode.Attribute("StartAt") != null?int.Parse(CommandNode.Attribute("StartAt").Value) : 0; var positions = from c in CommandNode.Descendants("Position") orderby int.Parse(c.Attribute("Start").Value) ascending select new { Name = c.Attribute("Name").Value, Start = int.Parse(c.Attribute("Start").Value) - StartAt, Length = int.Parse(c.Attribute("Length").Value), DefaultValue = c.Attribute("DefaultValue") != null?c.Attribute("DefaultValue").Value : string.Empty, //optional, Type = c.Attribute("Type") != null?c.Attribute("Type").Value : string.Empty, //optional ExistsInTable = Table.Columns.Contains(c.Attribute("Name").Value) }; int lineLength = positions.Last().Start + positions.Last().Length; using (var stream = new StreamWriter(outputStrmFilePath, true)) { // Use stream foreach (DataRow row in Table.Rows) { StringBuilder line = new StringBuilder(lineLength); foreach (var p in positions) { //check if the column exists in the datatable if (p.ExistsInTable) { if (!string.IsNullOrEmpty(p.DefaultValue)) { line.Insert(p.Start, (p.DefaultValue ?? "").ToString().PadRight(p.Length, ' ')); } else { if (!string.IsNullOrEmpty(p.Type) && p.Type == "N" && !string.IsNullOrEmpty(row[p.Name].ToString())) { int lengthallotted = p.Length - p.Start; string withzeroes = string.Empty; //check if the data is decimal, remove the decimal //padd zeroes to the right if (row[p.Name].ToString().Contains(".")) { string decimalremoved = row[p.Name].ToString().Replace(".", string.Empty); withzeroes = string.Empty.PadLeft(lengthallotted - decimalremoved.Length, '0') + decimalremoved.ToString(); line.Insert(p.Start, withzeroes); } else { withzeroes = lengthallotted > row[p.Name].ToString().Length ? string.Empty.PadLeft(lengthallotted - row[p.Name].ToString().Length, '0') + row[p.Name].ToString() : row[p.Name].ToString(); //withzeroes = string.Empty.PadLeft(lengthallotted - row[p.Name].ToString().Length, '0') + row[p.Name].ToString(); line.Insert(p.Start, withzeroes); } } else { line.Insert(p.Start, (row[p.Name] ?? "").ToString().PadRight(p.Length, ' ')); } } } else { //log an error and exit _logger.LogError("Error while generating POAPL file. Column name mismatch for--{column}", p.Name); break; } } stream.WriteLine(line.ToString()); } } } catch (Exception ex) { _logger.LogError("Method Name -- WriteFixedWidth: {Reason}", ex.Message); } }
private void WriteFixedWidth(System.Xml.Linq.XElement CommandNode, DataTable Table, string outputStrmFilePath) { try { int StartAt = CommandNode.Attribute("StartAt") != null?int.Parse(CommandNode.Attribute("StartAt").Value) : 0; var positions = from c in CommandNode.Descendants("Position") orderby int.Parse(c.Attribute("Start").Value) ascending select new { Name = c.Attribute("Name").Value, Start = int.Parse(c.Attribute("Start").Value) - StartAt, Length = int.Parse(c.Attribute("Length").Value), DefaultValue = c.Attribute("DefaultValue") != null?c.Attribute("DefaultValue").Value : string.Empty, //optional Type = c.Attribute("Type") != null?c.Attribute("Type").Value : string.Empty, //optional ExistsInTable = Table.Columns.Contains(c.Attribute("Name").Value) }; int lineLength = positions.Last().Start + positions.Last().Length; using (var stream = new StreamWriter(outputStrmFilePath, true)) { foreach (DataRow row in Table.Rows) { StringBuilder line = new StringBuilder(lineLength); foreach (var p in positions) { //check if the column exists in the datatable string rowData = string.Empty; if (p.ExistsInTable) { if (!string.IsNullOrEmpty(p.Type) && p.Type == "N" && !string.IsNullOrEmpty(row[p.Name].ToString())) { int lengthAllotted = p.Length - p.Start; string withzeroes = string.Empty; //check if the data is decimal, remove the decimal and padd zeroes to the right if (row[p.Name].ToString().Contains(".")) { string decimalremoved = row[p.Name].ToString(); withzeroes = string.Empty.PadLeft(lengthAllotted - decimalremoved.Length, '0') + decimalremoved.ToString(); } else { withzeroes = lengthAllotted > row[p.Name].ToString().Length ? string.Empty.PadLeft(lengthAllotted - row[p.Name].ToString().Length, '0') + row[p.Name].ToString() : row[p.Name].ToString(); } line.Append(withzeroes).Append("\t"); } else { rowData = row[p.Name] != null?Convert.ToString(row[p.Name]) : ""; int dataLength = (p.Length - p.Start) > rowData.Length ? rowData.Length : (p.Length - p.Start); line.Append(rowData.Substring(0, dataLength)).Append("\t"); } } else { line.Append(rowData).Append("\t"); _logger.LogError("Error while generating POFineLine file---Column name mismatch--{column} - " + p.Name); break; } } stream.WriteLine(line.ToString()); } } } catch (Exception ex) { _logger.LogError("Method Name -- WriteFixedWidth: {Reason}", ex.Message); } }