public DependencyNode(Project parent, File file, Project.CodeGroup group) { File = file; DoCompile = group == Project.c || group == Project.cpp; Group = group; Parents.Add(parent); }
/// <summary> /// Updates the cost of the vertex using its existing cost plus the /// cost to traverse the specified edge. If the search is in simple /// path mode, only one path will be accrued. /// </summary> /// <param name="vertex">The vertex to update.</param> /// <param name="edge">The edge through which the vertex is reached.</param> /// <param name="cost">The current cost to reach the vertex from the source.</param> /// <param name="replace">True to indicate that any accrued edges are not to be cleared. /// False to indicate that the edge should be added to the previously accrued edges as they yield the same cost.</param> public void UpdateVertex(V vertex, E edge, IWeight cost, bool replace) { Costs.AddOrSet(vertex, cost); if (edge is null) { return; } ISet <E> edges = Parents.GetOrDefault(vertex); if (edges is null) { edges = new HashSet <E>(); Parents.Add(vertex, edges); } if (replace) { edges.Clear(); } if (MaxPaths == AllPaths || edges.Count < MaxPaths) { edges.Add(edge); } }
/// <summary> /// Merges changes from other RenameResult. /// </summary> /// <param name="projectItem">ProjectItem associated with CodeElements</param> /// <param name="result">Rename operation result.</param> public void MergeChanges(ProjectItem projectItem, IRenameResult result) { if (string.IsNullOrEmpty(result.OldName)) { result.OldName = OldName; } if (result.Parents != null) { result.Parents.ForEach(parent => { if (!parents.Contains(parent)) { Parents.Add(parent); } }); } if (result is MultiRenameResult) { foreach (KeyValuePair <ProjectItem, IRenameResult> item in ((result as MultiRenameResult)).ChangedProjectElements) { MergeChanges(item.Key, item.Value); } } else { if (!changedProjectElements.ContainsKey(projectItem)) { changedProjectElements.Add(projectItem, result); } } }
public void AddParent(Person parent) { if (!Parents.Contains(parent)) { Parents.Add(parent); } }
// NOTE: // This region handles parent's Visibility to raise IsOffscreen UIA event. // The rule to do so is: IsOffscreen() depends on owner.Visibility and // "all its" parents.Visibility, for example, in: // // - C1 // -- C2 // --- C3 // owner // // If C1.Visibility is Collapsed then C3 IsOffscreen=true, even when // their C3.Visibility is Visible. private void CacheParents() { UIElement parent = VisualTreeHelper.GetParent(owner) as UIElement; if (cachedParent != parent) { cachedParent = parent; // Removing delegates in older parents if (parents != null) { foreach (UIElement parentItem in parents) { parentItem.UIAVisibilityChanged -= Parent_UIAVisibilityChanged; } parents.Clear(); } // Caching new parents and listening for their UIAVisibilityChanged if (parent != null) { Parents.Add(parent); parent.UIAVisibilityChanged += Parent_UIAVisibilityChanged; do { parent = VisualTreeHelper.GetParent(parent) as UIElement; if (parent != null) { parents.Add(parent); // At this time parents is not null parent.UIAVisibilityChanged += Parent_UIAVisibilityChanged; } } while (parent != null); } } }
private void AddParent(ReadFile readFile) { if (!Parents.Contains(readFile)) { Parents.Add(readFile); } }
public void AddParent(Parent parent) { bool allreadyExist = false; for (int i = 0; i < this.Parents.Count; i++) { if (this.Parents[i].Name == parent.Name && !string.IsNullOrEmpty(this.Parents[i].Name)) { this.Parents[i].DateOfBirth = parent.DateOfBirth; allreadyExist = true; break; } else if (this.Parents[i].DateOfBirth == parent.DateOfBirth && this.Parents[i].DateOfBirth != DateTime.MinValue) { this.Parents[i].Name = parent.Name; allreadyExist = true; break; } } if (!allreadyExist) { Parents.Add(parent); } }
internal DocumentFeeMapping() : base() { Fields.Add("ImportoNetto", new FieldMapping { PropertyName = "Amount" }); Fields.Add("IsPagamento", new FieldMapping { PropertyName = "IsFromPayment" }); Parents.Add( "IdSpesa", new DataRelationMapping { ParentColumn = "Nome", PropertyName = "Name", RelationName = "FK_Spese_SpeseDocumenti", }); Parents.Add( "IdCausaleIVA", new DataRelationMapping { ParentColumn = "Codice", ChildProperty = "Code", PropertyName = "Vat", ChildType = typeof(Vat), RelationName = "FK_CausaliIVA_SpeseDocumenti" }); }
protected void BuildParents() { var x = 0; string relPath; while (LocalEntries.TryGetValue("parent." + x, out relPath)) { if (_root != null && !String.IsNullOrEmpty(_root.FullName) && !String.IsNullOrEmpty(relPath)) { var rootDir = Path.GetDirectoryName(_root.FullName); if (!String.IsNullOrEmpty(rootDir)) { var absPath = Path.GetFullPath(Path.Combine(rootDir, relPath)); var fi = new FileInfo(absPath); if (fi.Exists) { var parent = new FileDictionaryTree(fi); Parents.Add(parent); } } } x++; // increment for the next parent } }
public void AddParent(RevisionGraphRevision parent, out int maxScore) { // Generate a LaneColor used for rendering if (Parents.Any()) { parent.LaneColor = parent.Score; } else { if (parent.LaneColor == -1) { parent.LaneColor = LaneColor; } } if (IsRelative) { parent.MakeRelative(); } Parents.Add(parent); parent.AddChild(this); maxScore = parent.EnsureScoreIsAbove(Score + 1); StartSegments.Add(new RevisionGraphSegment(parent, this)); }
/// <summary> /// This constructor creates a new instance with exact copies of the original's parents. /// But the constructed instance itself contains no initial properties or defaults. /// </summary> /// <param name="parents"></param> public FileDictionaryTree(IEnumerable <FileDictionaryTree> parents) { foreach (var parent in parents) { Parents.Add(new FileDictionaryTree(parent)); } }
public void AddParent(Guid i_gid) { if (!Parents.Contains(i_gid)) { Parents.Add(i_gid); } }
internal VatMapping() { Fields.Add("Id", new FieldMapping { PropertyName = "UniqueId" }); Fields.Add("Nome", new FieldMapping { PropertyName = "Name" }); Fields.Add("Codice", new FieldMapping { PropertyName = "Code" }); Fields.Add("Aliquota", new FieldMapping { PropertyName = "Rate" }); Fields.Add("Indeducibilità", new FieldMapping { PropertyName = "NonDeductible" }); Fields.Add("IsIntracomunitaria", new FieldMapping { PropertyName = "IsIntraCommunity" }); Fields.Add("IsSplitPayment", new FieldMapping { PropertyName = "IsSplitPayment" }); Parents.Add( "Natura", new DataRelationMapping { PropertyName = "NaturaPA", ParentColumn = "Natura", ChildProperty = "Code", UpstreamTransform = (key, row, obj) => PAHelpers.NaturaPA[(string)row[key]], }); }
public void AddPrent(Record parent) { if (!Parents.Any(r => r.Equals(parent))) { Parents.Add(parent); } }
internal BillingAddressMapping() { Fields.Add("Id", new FieldMapping { PropertyName = "UniqueId" }); Fields.Add("RagioneSociale1", new FieldMapping { PropertyName = "Name" }); Fields.Add("Indirizzo", new FieldMapping { PropertyName = "Street" }); Fields.Add("CodiceFiscale", new FieldMapping { PropertyName = "TaxIdentificationNumber" }); Fields.Add("PartitaIVA", new VatIdNumberFieldMapping()); Fields.Add("Località", new FieldMapping { PropertyName = "Town" }); Fields.Add("CAP", new FieldMapping { PropertyName = "PostalCode" }); Fields.Add("Provincia", new FieldMapping { PropertyName = "StateOrProvince" }); Parents.Add( "IdNazione", new DataRelationMapping { PropertyName = "Country", ParentColumn = "Nome", RelationName = "FK_Nazioni_Anagrafiche", } ); }
public void UpdateData(string[] data) { switch (data[1]) { case "company": Company = new Company(data[2], data[3], decimal.Parse(data[4])); break; case "pokemon": Pokemon pokemon = new Pokemon(data[2], data[3]); Pokemons.Add(pokemon); break; case "parents": Parent parent = new Parent(data[2], data[3]); Parents.Add(parent); break; case "children": Children children = new Children(data[2], data[3]); Childrens.Add(children); break; case "car": Car = new Car(data[2], int.Parse(data[3])); break; } }
/// <summary> /// Add parent information. /// </summary> /// <param name="parentTaxonTreeNode">Parent taxon tree node.</param> /// <param name="parentTaxonRelation">Parent taxon tree relation.</param> public void AddParent(TaxonTreeNode parentTaxonTreeNode, WebTaxonRelation parentTaxonRelation) { Int32 parentIndex; if (Parents.IsEmpty() || Parents[Parents.Count - 1].SortOrder <= parentTaxonTreeNode.SortOrder) { // Insert at the end of the lists. if (Parents.IsNull()) { ParentRelations = new List <WebTaxonRelation>(); Parents = new List <TaxonTreeNode>(); } ParentRelations.Add(parentTaxonRelation); Parents.Add(parentTaxonTreeNode); } else { // Insert into the list. for (parentIndex = 0; parentIndex < Parents.Count; parentIndex++) { if (parentTaxonTreeNode.SortOrder < Parents[parentIndex].SortOrder) { ParentRelations.Insert(parentIndex, parentTaxonRelation); Parents.Insert(parentIndex, parentTaxonTreeNode); break; } } } }
public void AddParent(ParentEntry entry) { if (Parents.ContainsKey(entry.Id)) { throw new ObjectAlreadyExistsException("Object is already parented by this parent"); } Parents.Add(entry.Id, entry); }
/// <summary> /// This constructor creates a new instance with exact copies of the original's parents. /// But the constructed instance itself contains no initial properties or defaults. /// </summary> public FileDictionaryTree(string name, string fullName, IEnumerable <FileDictionaryTree> parents) : this(name, fullName) { foreach (var parent in parents) { Parents.Add(new FileDictionaryTree(parent)); } }
/// <summary> /// This copy constructory creates a new instance that is identical to another instance, /// but with its own identity. That is, this is a deep-clone of the original (including /// recursive cloning of parents). /// Note that the new instance has the same "Name" and "FullName", even though its object identity is unique. /// </summary> /// <param name="other">The instance to copy.</param> public FileDictionaryTree(FileDictionaryTree other) : this(other.Name, other.FullName, other.LocalEntries, other.LocalDefaults) { foreach (var parent in other.Parents) { Parents.Add(new FileDictionaryTree(parent)); } }
public void AddParent(EntitySetHandle parent) { if (Parents == null) { Parents = new List <EntitySetHandle>(); } Parents.Add(parent); }
public bool AddParent(DependentItem parent) { if (Parents.Add(parent)) { Status = ItemStatus.Dependent; return(true); } return(false); }
/// <summary> /// This constructor accepts enumerable initial properties, defaults, and parents with which to create a new instance. /// </summary> public FileDictionaryTree(string name, string fullName, IEnumerable <KeyValuePair <string, string> > initialProperties, IEnumerable <KeyValuePair <string, string> > defaultProperties, IEnumerable <FileDictionaryTree> parents) : this(name, fullName, initialProperties, defaultProperties) { foreach (var parent in parents) { Parents.Add(new FileDictionaryTree(parent)); } }
/// <summary> /// Adds a node to the current node so that it is linked to it. /// </summary> /// <param name="node">The node to link this one to</param> /// <returns> /// True if successfully added to the list that this node links to. /// False if this node already links to that node. /// </returns> public bool AddLinkedNode(Node node) { if (!LinksTo.Contains(node)) { LinksTo.Add(node); Parents.Add(node); return(true); } return(false); }
internal void AppendTo(Node parent) { if (parent == null) { throw new ArgumentNullException("parent", "Argument(parent) is null!"); } if (!Parents.Any(p => p.Id.Equals(parent.Id))) { Parents.Add(parent); } }
//Create a parent with new children public void CreateParent() { Parents.Add(new Parent { Children = new List <Child> { new Child(), new Child(), new Child() } }); }
/// <summary> /// Processes the parent nodes. Since a parent may contain a parent, there may be /// a recursive call to self. /// </summary> /// <param name="reader">XmlTextReader</param> /// <param name="listParents">Parents</param> private void ProcessParent(XmlTextReader reader, Parents listParents) { string nodeName = string.Empty; bool bParent = true; Parent p = new Parent(); while (bParent && reader.Read()) { nodeName = reader.Name; switch (reader.NodeType) { case XmlNodeType.Text: p.ParentName = reader.Value.Trim(); break; case XmlNodeType.Element: if (nodeName.Equals("IdentName")) { nodeName = ProcessIdentityNode(reader, p.ListPairedValues); } // Parent containing parent, may also occur after processing the identities if (nodeName.Equals("Parent")) { ProcessParent(reader, p.ListParents); } else if (nodeName.Equals("EndParent")) { // this may occur after processing the identities. Will either be a new parent (above) or finished the parent bParent = false; listParents.Add(p); } break; case XmlNodeType.EndElement: bParent = false; listParents.Add(p); break; } } }
// Internal for testing internal async Task CreateParents(IEnumerable <IGrouping <string, ITestResult> > testResultsByParent, CancellationToken cancellationToken) { // Find the parents that don't exist string[] parentsToAdd = testResultsByParent .Select(x => x.Key) .Where(x => !Parents.ContainsKey(x)) .ToArray(); // Batch an add operation and record the new parent IDs DateTime startedDate = DateTime.UtcNow; if (parentsToAdd.Length > 0) { string request = "[ " + string.Join(", ", parentsToAdd.Select(x => { Dictionary <string, object> properties = new Dictionary <string, object> { { "testCaseTitle", x }, { "automatedTestName", x }, { "resultGroupType", "generic" }, { "outcome", "Passed" }, // Start with a passed outcome initially { "state", "InProgress" }, { "startedDate", startedDate.ToString("yyyy-MM-ddTHH:mm:ss.FFFZ") }, { "automatedTestType", "UnitTest" }, { "automatedTestTypeId", "13cdc9d9-ddb5-4fa4-a97d-d965ccfc6d4b" } // This is used in the sample response and also appears in web searches }; if (!string.IsNullOrEmpty(Source)) { properties.Add("automatedTestStorage", Source); } return(properties.ToJson()); })) + " ]"; string responseString = await _apiClient.SendAsync(HttpMethod.Post, TestRunEndpoint, "5.0", request, cancellationToken).ConfigureAwait(false); using (StringReader reader = new StringReader(responseString)) { JsonObject response = JsonDeserializer.Deserialize(reader) as JsonObject; JsonArray parents = (JsonArray)response.Value("value"); if (parents.Length != parentsToAdd.Length) { throw new Exception("Unexpected number of parents added"); } for (int c = 0; c < parents.Length; c++) { int id = ((JsonObject)parents[c]).ValueAsInt("id"); Parents.Add(parentsToAdd[c], new TestResultParent(id, startedDate)); } } } }
public void Bind() { Parents.Clear(); _words = Data.Access.GetSemanticTypes(); foreach (SemanticType type in _words) { SemanticTypeViewModel parent = new SemanticTypeViewModel(type); AddNode(parent); if (parent.ParentId == 0) { parent.IsExpanded = true; Parents.Add(parent); } } }
internal void AddParent(int hash) { if (hash == 0) { return; } if (!Parents.ContainsKey(hash)) { Parents.Add(hash, 1); } else { Parents[hash]++; } }