source: branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraphNode.cs @ 11262

Last change on this file since 11262 was 11262, checked in by bburlacu, 7 years ago

#1772: Added missing Storable constructor to GenealogyGraphNode<T> class. Prefer cloning vertices in the GenealogyAnalyzer. Add In/Out Degree in node tooltip in the GenealogyGraphChart.

File size: 5.4 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Linq;
25using HeuristicLab.Common;
26using HeuristicLab.Core;
27using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
28
29namespace HeuristicLab.EvolutionTracking {
30  [StorableClass]
31  [Item("GenealogGraphNode", "A class representing a node in the GenealogyGraph")]
32  public class GenealogyGraphNode : Vertex, IGenealogyGraphNode {
33    [StorableConstructor]
34    protected GenealogyGraphNode(bool deserializing) : base(deserializing) { }
35
36    public override IDeepCloneable Clone(Cloner cloner) {
37      return new GenealogyGraphNode(this, cloner);
38    }
39
40    protected GenealogyGraphNode(GenealogyGraphNode original, Cloner cloner)
41      : base(original, cloner) {
42      Quality = original.Quality;
43      Rank = original.Rank;
44      IsElite = original.IsElite;
45      Id = Guid.NewGuid().ToString();
46    }
47
48    public GenealogyGraphNode(IDeepCloneable data)
49      : base(data) {
50      Id = Guid.NewGuid().ToString();
51    }
52
53    public new IEnumerable<IGenealogyGraphArc> InArcs {
54      get { return base.InArcs.Cast<IGenealogyGraphArc>(); }
55    }
56
57    public new IEnumerable<IGenealogyGraphArc> OutArcs {
58      get { return base.OutArcs.Cast<IGenealogyGraphArc>(); }
59    }
60
61    public IEnumerable<IGenealogyGraphNode> Ancestors {
62      get {
63        // for performance, we use a hashset for lookup and a list for iteration
64        var nodes = new HashSet<IGenealogyGraphNode> { this };
65        var list = new List<IGenealogyGraphNode> { this };
66        int i = 0;
67        while (i != list.Count) {
68          foreach (var e in list[i].InArcs) {
69            if (nodes.Contains(e.Source)) continue;
70            nodes.Add(e.Source);
71            list.Add(e.Source);
72          }
73          ++i;
74        }
75        return list;
76      }
77    }
78    /// <summary>
79    /// Performs a downward-breath-traversal of the genealogy graph using the nodes OutArcs
80    /// </summary>
81    /// <returns>All the descendants of the current node</returns>
82    public IEnumerable<IGenealogyGraphNode> Descendants {
83      get {
84        var nodes = new HashSet<IGenealogyGraphNode> { this };
85        var list = new List<IGenealogyGraphNode> { this };
86        int i = 0;
87        while (i != list.Count) {
88          foreach (var e in list[i].OutArcs) {
89            if (nodes.Contains(e.Target)) continue;
90            nodes.Add(e.Target);
91            list.Add(e.Target);
92          }
93          ++i;
94        }
95        return list;
96      }
97    }
98    [Storable]
99    public string Id { get; private set; }
100
101    [Storable]
102    private double rank;
103    public double Rank {
104      get { return rank; }
105      set { rank = value; }
106    }
107    [Storable]
108    private double quality;
109    public double Quality {
110      get { return quality; }
111      set { quality = value; }
112    }
113    [Storable]
114    private bool isElite;
115    public bool IsElite {
116      get { return isElite; }
117      set { isElite = value; }
118    }
119    public int CompareTo(IGenealogyGraphNode other) {
120      return Quality.CompareTo(other.Quality);
121    }
122    public IEnumerable<IGenealogyGraphNode> Parents {
123      get { return InArcs.Select(a => a.Source); }
124    }
125    public IEnumerable<IGenealogyGraphNode> Children {
126      get { return OutArcs.Select(a => a.Target); }
127    }
128  }
129
130  [StorableClass]
131  [Item("GenealogyGraphNode", "A genealogy graph node which also has a Content")]
132  public class GenealogyGraphNode<T> : GenealogyGraphNode, IGenealogyGraphNode<T> where T : class, IItem {
133    public new T Data {
134      get { return (T)base.Data; }
135      set { base.Data = value; }
136    }
137
138    [StorableConstructor]
139    protected GenealogyGraphNode(bool deserializing) : base(deserializing) { }
140
141    public GenealogyGraphNode(IDeepCloneable content) : base(content) { }
142
143    protected GenealogyGraphNode(GenealogyGraphNode<T> original, Cloner cloner)
144      : base(original, cloner) {
145    }
146    public override IDeepCloneable Clone(Cloner cloner) {
147      return new GenealogyGraphNode<T>(this, cloner);
148    }
149    public new IEnumerable<IGenealogyGraphNode<T>> Parents {
150      get { return base.Parents.Cast<IGenealogyGraphNode<T>>(); }
151    }
152    public new IEnumerable<IGenealogyGraphNode<T>> Children {
153      get { return base.Children.Cast<IGenealogyGraphNode<T>>(); }
154    }
155    public new IEnumerable<IGenealogyGraphNode<T>> Ancestors {
156      get { return base.Ancestors.Cast<IGenealogyGraphNode<T>>(); }
157    }
158    public new IEnumerable<IGenealogyGraphNode<T>> Descendants {
159      get { return base.Descendants.Cast<IGenealogyGraphNode<T>>(); }
160    }
161  }
162}
Note: See TracBrowser for help on using the repository browser.