Changeset 11233 for branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraph.cs

Timestamp:

07/30/14 01:41:54 (10 years ago)

Author:

bburlacu

Message:

#1772: Worked towards integrating the new graph api with the tracking operators.

File:

• branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraph.cs (modified) (5 diffs)

branches/HeuristicLab.EvolutionTracking/HeuristicLab.EvolutionTracking/3.4/GenealogyGraph/GenealogyGraph.cs

@@ -32 +32 @@
   public class GenealogyGraph : DirectedGraph, IGenealogyGraph {
     [Storable]
+    private readonly Dictionary<object, IGenealogyGraphNode> contentMap;
+
+    [Storable]
+    private readonly Dictionary<string, IGenealogyGraphNode> idMap;
+
+    [Storable]
     private Dictionary<double, List<IGenealogyGraphNode>> ranks; // use a linked list for fast insertion/removal
     public Dictionary<double, List<IGenealogyGraphNode>> Ranks {
@@ -37 +43 @@
       set { ranks = value; }
     }
-    public new IEnumerable<IGenealogyGraphNode> Vertices {
-      get { return from n in base.Vertices select (IGenealogyGraphNode)n; }
-    }
 
     protected GenealogyGraph(GenealogyGraph original, Cloner cloner)
       : base(original, cloner) {
       Ranks = new Dictionary<double, List<IGenealogyGraphNode>>(original.Ranks);
-    }
+      contentMap = new Dictionary<object, IGenealogyGraphNode>(original.contentMap);
+      idMap = new Dictionary<string, IGenealogyGraphNode>(original.idMap);
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new GenealogyGraph(this, cloner);
     }
+
     [StorableConstructor]
     protected GenealogyGraph(bool deserializing) : base(deserializing) { }
     public GenealogyGraph() {
       Ranks = new Dictionary<double, List<IGenealogyGraphNode>>();
+      contentMap = new Dictionary<object, IGenealogyGraphNode>();
+      idMap = new Dictionary<string, IGenealogyGraphNode>();
+    }
+
+    public new IEnumerable<IGenealogyGraphNode> Vertices {
+      get { return from n in base.Vertices select (IGenealogyGraphNode)n; }
     }
 
     public override IArc AddArc(IVertex source, IVertex target) {
       var arc = new GenealogyGraphArc((IGenealogyGraphNode)source, (IGenealogyGraphNode)target);
-      source.AddForwardArc(arc);
-      target.AddReverseArc(arc);
+      source.AddArc(arc);
+      target.AddArc(arc);
       arcs.Add(arc);
       return arc;
@@ -68 +81 @@
         Ranks[node.Rank] = new List<IGenealogyGraphNode>();
       Ranks[node.Rank].Add(node);
-    }
+
+      if (contentMap.ContainsKey(node.Content))
+        throw new InvalidOperationException("Duplicate content is not allowed in the genealogy graph.");
+      contentMap[node.Content] = node;
+
+      if (idMap.ContainsKey(node.Id))
+        throw new InvalidOperationException("Duplicate content is not allowed in the genealogy graph.");
+      idMap[node.Id] = node;
+
+      vertex.Changed += OnVertexChanged;
+    }
+
     public override void RemoveVertex(IVertex vertex) {
       var node = (IGenealogyGraphNode)vertex;
+      contentMap.Remove(node.Content);
+      idMap.Remove(node.Id);
       if (Ranks.ContainsKey(node.Rank)) {
         Ranks[node.Rank].Remove(node);
@@ -76 +102 @@
       base.RemoveVertex(vertex);
     }
+
+    public IGenealogyGraphNode GetByContent(object content) {
+      IGenealogyGraphNode result;
+      contentMap.TryGetValue(content, out result);
+      return result;
+    }
+
+    public IGenealogyGraphNode GetById(string id) {
+      IGenealogyGraphNode result;
+      idMap.TryGetValue(id, out result);
+      return result;
+    }
+
+    public bool Contains(object content) {
+      return contentMap.ContainsKey(content);
+    }
+
     public event EventHandler GraphUpdated;
     private void OnGraphUpdated(object sender, EventArgs args) {
@@ -86 +129 @@
       ranks.Clear();
     }
+
+    protected override void OnVertexChanged(object sender, EventArgs args) {
+      base.OnVertexChanged(sender, args);
+
+      var vertex = (IGenealogyGraphNode)sender;
+      if (!contentMap.ContainsKey(vertex.Content)) {
+        // vertex has received new content
+      }
+    }
   }
 
+  //  [StorableClass]
+  //  [Item("GenealogyGraph", "A class representing a genealogy graph")]
+  //  public class GenealogyGraph<T> : DirectedGraph, IGenealogyGraph<T> where T : class, IItem {
+  //    // members and properties
+  //    [Storable]
+  //    private Dictionary<double, List<IGenealogyGraphNode>> ranks;
+  //    public Dictionary<double, List<IGenealogyGraphNode>> Ranks {
+  //      get { return ranks; }
+  //      set { ranks = value; }
+  //    }
+  //    public new IEnumerable<IGenealogyGraphNode<T>> Vertices {
+  //      get { return from n in base.Vertices select (IGenealogyGraphNode<T>)n; }
+  //    }
+  //    // contructors
+  //    protected GenealogyGraph(GenealogyGraph<T> original, Cloner cloner)
+  //      : base(original, cloner) {
+  //    }
+  //    public override IDeepCloneable Clone(Cloner cloner) {
+  //      return new GenealogyGraph<T>(this, cloner);
+  //    }
+  //
+  //    [StorableConstructor]
+  //    protected GenealogyGraph(bool deserializing) : base(deserializing) { }
+  //    public GenealogyGraph() {
+  //      Ranks = new Dictionary<double, List<IGenealogyGraphNode>>();
+  //    }
+  //
+  //    // methods
+  //    public override void AddVertex(IVertex vertex) {
+  //      base.AddVertex(vertex);
+  //      var node = (IGenealogyGraphNode)vertex;
+  //      if (!Ranks.ContainsKey(node.Rank)) {
+  //        Ranks[node.Rank] = new List<IGenealogyGraphNode>();
+  //      }
+  //      Ranks[node.Rank].Add(node);
+  //    }
+  //
+  //    public override void RemoveVertex(IVertex vertex) {
+  //      var node = (IGenealogyGraphNode<T>)vertex;
+  //      if (Ranks.ContainsKey(node.Rank)) {
+  //        Ranks[node.Rank].Remove(node);
+  //      }
+  //      base.RemoveVertex(vertex);
+  //    }
+  //
+  //    public override IArc AddArc(IVertex source, IVertex target) {
+  //      var arc = new GenealogyGraphArc((IGenealogyGraphNode)source, (IGenealogyGraphNode)target);
+  //      source.AddArc(arc);
+  //      target.AddArc(arc);
+  //      arcs.Add(arc);
+  //      return arc;
+  //    }
+  //
+  //    IEnumerable<IGenealogyGraphNode> IGenealogyGraph.Vertices {
+  //      get { return Vertices; }
+  //    }
+  //
+  //    public IGenealogyGraphNode GetByContent(object content)
+  //    {
+  //      IGenealogyGraphNode result;
+  //      contentMap.
+  //    }
+  //
+  //    public event EventHandler GraphUpdated;
+  //    private void OnGraphUpdated(object sender, EventArgs args) {
+  //      var updated = GraphUpdated;
+  //      if (updated != null) updated(sender, args);
+  //    }
+  //  }
   [StorableClass]
-  [Item("GenealogyGraph", "A class representing a genealogy graph")]
-  public class GenealogyGraph<T> : DirectedGraph, IGenealogyGraph<T> where T : class, IItem {
-    // members and properties
-    [Storable]
-    private Dictionary<double, List<IGenealogyGraphNode>> ranks;
-    public Dictionary<double, List<IGenealogyGraphNode>> Ranks {
-      get { return ranks; }
-      set { ranks = value; }
-    }
+
+  [Item("GenealogyGraph", "A specialization of the genealogy graph with T as content for vertices")]
+  public class GenealogyGraph<T> : GenealogyGraph, IGenealogyGraph<T> where T : class, IItem {
     public new IEnumerable<IGenealogyGraphNode<T>> Vertices {
-      get { return from n in base.Vertices select (IGenealogyGraphNode<T>)n; }
-    }
-    // contructors
-    protected GenealogyGraph(GenealogyGraph<T> original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new GenealogyGraph<T>(this, cloner);
-    }
-    [StorableConstructor]
-    protected GenealogyGraph(bool deserializing) : base(deserializing) { }
-    public GenealogyGraph() {
-      Ranks = new Dictionary<double, List<IGenealogyGraphNode>>();
-    }
-    // methods
-    public override void AddVertex(IVertex vertex) {
-      base.AddVertex(vertex);
-      var node = (IGenealogyGraphNode)vertex;
-      if (!Ranks.ContainsKey(node.Rank)) {
-        Ranks[node.Rank] = new List<IGenealogyGraphNode>();
-      }
-      Ranks[node.Rank].Add(node);
-    }
-    public override void RemoveVertex(IVertex vertex) {
-      var node = (IGenealogyGraphNode<T>)vertex;
-      if (Ranks.ContainsKey(node.Rank)) {
-        Ranks[node.Rank].Remove(node);
-      }
-      base.RemoveVertex(vertex);
-    }
-    public override IArc AddArc(IVertex source, IVertex target) {
-      var arc = new GenealogyGraphArc((IGenealogyGraphNode)source, (IGenealogyGraphNode)target);
-      source.AddForwardArc(arc);
-      target.AddReverseArc(arc);
-      arcs.Add(arc);
-      return arc;
-    }
-    IEnumerable<IGenealogyGraphNode> IGenealogyGraph.Vertices {
-      get { return Vertices; }
-    }
-    public event EventHandler GraphUpdated;
-    private void OnGraphUpdated(object sender, EventArgs args) {
-      var updated = GraphUpdated;
-      if (updated != null) updated(sender, args);
+      get { return base.Vertices.Cast<IGenealogyGraphNode<T>>(); }
     }
   }