Changeset 11935 for stable

Timestamp:

02/06/15 11:59:12 (10 years ago)

Author:

jkarder

Message:

#2223: merged r11241, r11243, r11248, r11249, r11250, r11251, r11256, r11263, r11324, r11389, r11391, r11444, r11853, r11879, r11912 and r11913 into stable

Location:

stable

Files:

• . (modified) (1 prop)
• HeuristicLab.Core/3.3/Collections/DirectedGraph (copied) (copied from trunk/sources/HeuristicLab.Core/3.3/Collections/DirectedGraph)
• HeuristicLab.Core/3.3/Collections/DirectedGraph/Arc.cs (modified) (5 diffs)
• HeuristicLab.Core/3.3/Collections/DirectedGraph/DirectedGraph.cs (modified) (6 diffs)
• HeuristicLab.Core/3.3/Collections/DirectedGraph/Vertex.cs (modified) (7 diffs)
• HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj (modified) (2 diffs)
• HeuristicLab.Core/3.3/Interfaces/DirectedGraph (copied) (copied from trunk/sources/HeuristicLab.Core/3.3/Interfaces/DirectedGraph)
• HeuristicLab.Core/3.3/Interfaces/DirectedGraph/IArc.cs (modified) (1 diff)
• HeuristicLab.Core/3.3/Interfaces/DirectedGraph/IDirectedGraph.cs (modified) (1 diff)
• HeuristicLab.Core/3.3/Interfaces/DirectedGraph/IVertex.cs (modified) (2 diffs)

stable/HeuristicLab.Core/3.3/Collections/DirectedGraph/Arc.cs

@@ -25 +25 @@
 
 namespace HeuristicLab.Core {
-  /// <summary>
-  /// An arc that can have a weight, a label, and a data object for holding additional info
-  /// </summary>
+  [Item("Arc", "A graph arc connecting two graph vertices, that can have a weight, label, and data object for holding additional info")]
   [StorableClass]
   public class Arc : Item, IArc {
@@ -58 +56 @@
     }
 
-    [Storable]
-    protected IDeepCloneable data;
-    public IDeepCloneable Data {
-      get { return data; }
-      set {
-        if (data == value) return;
-        data = value;
-        OnChanged(this, EventArgs.Empty);
-      }
-    }
 
     [StorableConstructor]
-    public Arc(bool deserializing) : base(deserializing) { }
+    protected Arc(bool deserializing) : base(deserializing) { }
 
     public Arc(IVertex source, IVertex target) {
@@ -83 +71 @@
       label = original.Label;
       weight = original.Weight;
-      data = cloner.Clone(data);
     }
     public override IDeepCloneable Clone(Cloner cloner) { return new Arc(this, cloner); }
@@ -96 +83 @@
 
   [StorableClass]
-  public class Arc<T> : Arc, IArc<T> where T : class,IItem {
+  public class Arc<T> : Arc, IArc<T> where T : class,IDeepCloneable {
+    [Storable]
+    protected T data;
+    public T Data {
+      get { return data; }
+      set {
+        if (data == value) return;
+        data = value;
+        OnChanged(this, EventArgs.Empty);
+      }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Arc<T>(this, cloner);
+    }
+
+    protected Arc(Arc<T> original, Cloner cloner)
+      : base(original, cloner) {
+      if (original.Data != null)
+        Data = cloner.Clone(original.Data);
+    }
+
     public Arc(bool deserializing)
       : base(deserializing) {
@@ -108 +116 @@
       : base(original, cloner) {
     }
-
-    new public IVertex<T> Source {
-      get { return (IVertex<T>)base.Source; }
-    }
-    new public IVertex<T> Target {
-      get { return (IVertex<T>)base.Target; }
-    }
   }
 }

stable/HeuristicLab.Core/3.3/Collections/DirectedGraph/DirectedGraph.cs

@@ -57 +57 @@
       vertices = new HashSet<IVertex>(original.vertices.Select(cloner.Clone));
       arcs = new HashSet<IArc>(original.arcs.Select(cloner.Clone));
+
+      // add the arcs to the newly cloned vertices
+      foreach (var arc in arcs) {
+        arc.Source.AddArc(arc);
+        arc.Target.AddArc(arc);
+      }
     }
 
@@ -71 +77 @@
     private void AfterDeserialization() {
       foreach (var vertex in vertices) {
-        vertex.ArcAdded += OnArcAdded;
-        vertex.ArcRemoved += OnArcRemoved;
+        vertex.ArcAdded += Vertex_ArcAdded;
+        vertex.ArcRemoved += Vertex_ArcRemoved;
       }
 
@@ -89 +95 @@
 
     public virtual void AddVertex(IVertex vertex) {
-      vertices.Add(vertex);
-      // register event handlers
-      vertex.ArcAdded += OnArcAdded;
-      vertex.ArcRemoved += OnArcRemoved;
+      if (!vertices.Contains(vertex) && vertex.Degree > 0)
+        throw new ArgumentException("New vertices cannot have any arcs.");
+
+      if (vertices.Add(vertex)) {
+        // register event handlers
+        vertex.ArcAdded += Vertex_ArcAdded;
+        vertex.ArcRemoved += Vertex_ArcRemoved;
+        OnVertexAdded(this, new EventArgs<IVertex>(vertex));
+      }
+    }
+
+    public virtual void AddVertices(IEnumerable<IVertex> vertexList) {
+      foreach (var v in vertexList) { AddVertex(v); }
+    }
+
+    public virtual void RemoveVertices(IEnumerable<IVertex> vertexList) {
+      foreach (var v in vertexList) { RemoveVertex(v); }
     }
 
@@ -102 +121 @@
         RemoveArc(arc);
       // deregister event handlers
-      vertex.ArcAdded -= OnArcAdded;
-      vertex.ArcRemoved -= OnArcRemoved;
+      vertex.ArcAdded -= Vertex_ArcAdded;
+      vertex.ArcRemoved -= Vertex_ArcRemoved;
+      OnVertexRemoved(this, new EventArgs<IVertex>(vertex));
     }
 
@@ -113 +133 @@
 
     public virtual void AddArc(IArc arc) {
-      var source = (Vertex)arc.Source;
-      var target = (Vertex)arc.Target;
+      var source = arc.Source;
+      var target = arc.Target;
+
+      if (source == target)
+        throw new InvalidOperationException("Source and target cannot be the same.");
+
+      if (!vertices.Contains(source) || !vertices.Contains(target))
+        throw new InvalidOperationException("Cannot add arc connecting vertices that are not in the graph.");
+
       source.AddArc(arc);
       target.AddArc(arc);
       arcs.Add(arc);
+    }
+
+    public virtual void AddArcs(IEnumerable<IArc> arcList) {
+      foreach (var a in arcList) { AddArc(a); }
     }
 
@@ -128 +159 @@
     }
 
-    public event EventHandler ArcAdded;
+    public virtual void RemoveArcs(IEnumerable<IArc> arcList) {
+      foreach (var a in arcList) { RemoveArc(a); }
+    }
+
+    protected virtual void Vertex_ArcAdded(object sender, EventArgs<IArc> args) {
+      // the ArcAdded event is fired by a vertex when an arc from/to another vertex is added to its list of connections
+      // because the arc is added in both directions by both the source and the target, this event will get fired twice here
+      var arc = args.Value;
+      if (arcs.Add(arc)) OnArcAdded(this, new EventArgs<IArc>(arc));
+    }
+
+    protected virtual void Vertex_ArcRemoved(object sender, EventArgs<IArc> args) {
+      var arc = args.Value;
+      if (arcs.Remove(arc)) OnArcRemoved(this, new EventArgs<IArc>(arc));
+    }
+
+    // events
+    public event EventHandler<EventArgs<IVertex>> VertexAdded;
+    protected virtual void OnVertexAdded(object sender, EventArgs<IVertex> args) {
+      var added = VertexAdded;
+      if (added != null)
+        added(sender, args);
+    }
+
+    public event EventHandler<EventArgs<IVertex>> VertexRemoved;
+    protected virtual void OnVertexRemoved(object sender, EventArgs<IVertex> args) {
+      var removed = VertexRemoved;
+      if (removed != null)
+        removed(sender, args);
+    }
+
+    public event EventHandler<EventArgs<IArc>> ArcAdded;
     protected virtual void OnArcAdded(object sender, EventArgs<IArc> args) {
-      var arc = args.Value;
-      // the ArcAdded event is fired by a vertex when an arc from or towards another vertex is added to his list of connections
-      // because the arc is added in both directions by both the source and the target, this event will get fired twice 
-      // here, we only want to add the arc once, so if its already contained, we return without complaining
-      if (arcs.Contains(arc)) return;
-      arcs.Add(arc);
-    }
-
-
-    public event EventHandler ArcRemoved;
+      var added = ArcAdded;
+      if (added != null)
+        added(sender, args);
+    }
+
+    public event EventHandler<EventArgs<IArc>> ArcRemoved;
     protected virtual void OnArcRemoved(object sender, EventArgs<IArc> args) {
-      var arc = args.Value;
-      if (!arcs.Contains(arc)) return; // the same rationale as above 
-      arcs.Remove(arc);
-    }
-
-    // events
-    public event EventHandler VertexAdded;
-    public event EventHandler VertexRemoved;
+      var removed = ArcRemoved;
+      if (removed != null)
+        removed(sender, args);
+    }
   }
 }

stable/HeuristicLab.Core/3.3/Collections/DirectedGraph/Vertex.cs

@@ -27 +27 @@
 
 namespace HeuristicLab.Core {
+  [Item("Vertex", "An object representing a vertex in the graph. It can have a text label, a weight, and an additional data object.")]
   [StorableClass]
   public class Vertex : Item, IVertex {
@@ -51 +52 @@
     }
 
-    [Storable]
-    private IDeepCloneable data;
-    public IDeepCloneable Data {
-      get { return data; }
-      set {
-        if (data == value) return;
-        data = value;
-        OnChanged(this, EventArgs.Empty);
-      }
-    }
-
     private readonly List<IArc> inArcs = new List<IArc>();
     public IEnumerable<IArc> InArcs {
@@ -82 +72 @@
     private void AfterDeserialization() { }
 
-    public Vertex(IDeepCloneable data) {
-      this.data = data;
-    }
+    public Vertex() { }
 
     protected Vertex(Vertex original, Cloner cloner)
       : base(original, cloner) {
-      data = cloner.Clone(original.Data);
       label = original.Label;
       weight = original.Weight;
-
-      inArcs = original.InArcs.Select(cloner.Clone).ToList();
-      outArcs = original.OutArcs.Select(cloner.Clone).ToList();
+      // we do not clone the arcs here (would cause too much recursion and ultimately a stack overflow)
     }
 
@@ -102 +87 @@
     public void AddArc(IArc arc) {
       if (this != arc.Source && this != arc.Target)
-        throw new InvalidOperationException("The current vertex must be either the arc source or the arc target.");
+        throw new ArgumentException("The current vertex must be either the arc source or the arc target.");
+
+      if (arc.Source == arc.Target)
+        throw new ArgumentException("Arc source and target must be different.");
 
       if (this == arc.Source) {
@@ -117 +105 @@
     public void RemoveArc(IArc arc) {
       if (this != arc.Source && this != arc.Target)
-        throw new InvalidOperationException("The current vertex must be either the arc source or the arc target.");
+        throw new ArgumentException("The current vertex must be either the arc source or the arc target.");
 
       if (this == arc.Source) {
@@ -154 +142 @@
 
   [StorableClass]
-  public class Vertex<T> : Vertex, IVertex<T> where T : class,IItem {
-    public new T Data {
-      get { return (T)base.Data; }
-      set { base.Data = value; }
+  public class Vertex<T> : Vertex, IVertex<T> where T : class,IDeepCloneable {
+    [Storable]
+    private T data;
+    public T Data {
+      get { return data; }
+      set {
+        if (data == value) return;
+        data = value;
+        OnChanged(this, EventArgs.Empty);
+      }
     }
 
@@ -165 +159 @@
     protected Vertex(Vertex<T> original, Cloner cloner)
       : base(original, cloner) {
+      if (original.Data != null)
+        Data = cloner.Clone(original.Data);
     }
+
+    public Vertex() : base() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {

stable/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj

@@ -122 +122 @@
     <Compile Include="Collections\CheckedItemCollection.cs" />
     <Compile Include="Collections\CheckedItemList.cs" />
+    <Compile Include="Collections\DirectedGraph\Arc.cs" />
+    <Compile Include="Collections\DirectedGraph\DirectedGraph.cs" />
+    <Compile Include="Collections\DirectedGraph\Vertex.cs" />
     <Compile Include="Collections\ReadOnlyCheckedItemCollection.cs" />
     <Compile Include="Collections\ReadOnlyCheckedItemList.cs">
@@ -154 +157 @@
     <Compile Include="Constraints\IConstraint.cs" />
     <Compile Include="Constraints\TypeCompatibilityConstraint.cs" />
+    <Compile Include="Interfaces\DirectedGraph\IArc.cs" />
+    <Compile Include="Interfaces\DirectedGraph\IDirectedGraph.cs" />
+    <Compile Include="Interfaces\DirectedGraph\IVertex.cs" />
     <Compile Include="Interfaces\ICheckedMultiOperator.cs" />
     <Compile Include="Interfaces\IConstrainedValueParameter.cs" />

stable/HeuristicLab.Core/3.3/Interfaces/DirectedGraph/IArc.cs

@@ -29 +29 @@
     string Label { get; set; }
     double Weight { get; set; }
-    IDeepCloneable Data { get; set; }
 
     event EventHandler Changed; // generic event for when the label, weight or data were changed
   }
 
-  public interface IArc<T> : IArc where T : class,IItem {
-    new IVertex<T> Source { get; }
-    new IVertex<T> Target { get; }
+  public interface IArc<T> : IArc where T : class,IDeepCloneable {
+    T Data { get; set; }
   }
 }

stable/HeuristicLab.Core/3.3/Interfaces/DirectedGraph/IDirectedGraph.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Core {
   public interface IDirectedGraph : IItem {
-    void Clear();
-    void AddVertex(IVertex vertex);
-    IArc AddArc(IVertex source, IVertex target);
-    void AddArc(IArc arc);
-    void RemoveVertex(IVertex vertex);
-    void RemoveArc(IArc arc);
     IEnumerable<IVertex> Vertices { get; }
     IEnumerable<IArc> Arcs { get; }
 
-    event EventHandler VertexAdded;
-    event EventHandler VertexRemoved;
-    event EventHandler ArcAdded;
-    event EventHandler ArcRemoved;
+    void Clear();
+    void AddVertex(IVertex vertex);
+    void RemoveVertex(IVertex vertex);
+
+    void AddVertices(IEnumerable<IVertex> vertexList);
+    void RemoveVertices(IEnumerable<IVertex> vertexList);
+
+    IArc AddArc(IVertex source, IVertex target);
+    void AddArc(IArc arc);
+    void RemoveArc(IArc arc);
+
+    void AddArcs(IEnumerable<IArc> arcs);
+    void RemoveArcs(IEnumerable<IArc> removeArcs);
+
+    event EventHandler<EventArgs<IVertex>> VertexAdded;
+    event EventHandler<EventArgs<IVertex>> VertexRemoved;
+    event EventHandler<EventArgs<IArc>> ArcAdded;
+    event EventHandler<EventArgs<IArc>> ArcRemoved;
   }
 }

stable/HeuristicLab.Core/3.3/Interfaces/DirectedGraph/IVertex.cs

@@ -36 +36 @@
     double Weight { get; set; }
 
-    IDeepCloneable Data { get; set; }
-
     void AddArc(IArc arc);
     void RemoveArc(IArc arc);
@@ -46 +44 @@
   }
 
-  public interface IVertex<T> : IVertex
-  where T : class {
-    new T Data { get; set; }
+  public interface IVertex<T> : IVertex where T : class, IDeepCloneable {
+    T Data { get; set; }
   }
 }