Changeset 2046 for branches/Operator Architecture Refactoring

Timestamp:

06/16/09 03:36:48 (15 years ago)

Author:

swagner

Message:

Refactoring of the operator architecture (#95)

Location:

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3

Files:

• AliasEventArgs.cs (deleted)
• CallGraph.cs (modified) (1 diff)
• CallGraphView.Designer.cs (added)
• CallGraphView.cs (added)
• CallGraphView.resx (added)
• CallNode.cs (deleted)
• CallNodeBase.cs (added)
• CancelEventArgs.cs (added)
• Cloner.cs (modified) (1 diff)
• EngineBase.cs (modified) (3 diffs)
• EventArgs.cs (added)
• ExceptionEventArgs.cs (deleted)
• HeuristicLab.Core-3.3.csproj (modified) (9 diffs)
• Interfaces/ICallGraph.cs (modified) (1 diff)
• Interfaces/ICallNode.cs (modified) (1 diff)
• Interfaces/IEngine.cs (modified) (1 diff)
• Interfaces/IOperator.cs (modified) (1 diff)
• Interfaces/IOperatorGraph.cs (modified) (1 diff)
• Interfaces/IParameter.cs (modified) (1 diff)
• Interfaces/IScope.cs (modified) (1 diff)
• Interfaces/IVariable.cs (modified) (1 diff)
• ItemEventArgs.cs (deleted)
• ItemIndexEventArgs.cs (deleted)
• KeyValueEventArgs.cs (deleted)
• NameChangingEventArgs.cs (deleted)
• OperationEventArgs.cs (deleted)
• OperatorBase.cs (modified) (3 diffs)
• OperatorCallNode.cs (added)
• OperatorEventArgs.cs (deleted)
• OperatorGraph.cs (modified) (3 diffs)
• OperatorIndexEventArgs.cs (deleted)
• ParameterEventArgs.cs (deleted)
• Scope.cs (modified) (5 diffs)
• ScopeEventArgs.cs (deleted)
• ScopeIndexEventArgs.cs (deleted)
• Variable.cs (modified) (2 diffs)
• VariableEventArgs.cs (deleted)
• VariableInfoEventArgs.cs (deleted)

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/CallGraph.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Core {
-  public class CallGraph : ItemBase, ICallGraph {
+  public class CallGraph : CallNodeBase, ICallGraph {
+    [Storable]
+    private Dictionary<ICallNode, List<ICallNode>> transitions;
+
+    [Storable]
+    private List<ICallNode> myCallNodes;
+    public ICollection<ICallNode> CallNodes {
+      get { return myCallNodes.AsReadOnly(); }
+    }
+    [Storable]
+    private ICallNode myInitialCallNode;
+    public ICallNode InitialCallNode {
+      get { return myInitialCallNode; }
+      internal set {
+        if (myInitialCallNode != value) {
+          myInitialCallNode = value;
+          OnInitialCallNodeChanged();
+        }
+      }
+    }
+
+    public CallGraph()
+      : base() {
+      transitions = new Dictionary<ICallNode, List<ICallNode>>();
+      myCallNodes = new List<ICallNode>();
+      myInitialCallNode = null;
+    }
+    public CallGraph(CallGraph parentGraph)
+      : base(parentGraph) {
+      transitions = new Dictionary<ICallNode, List<ICallNode>>();
+      myCallNodes = new List<ICallNode>();
+      myInitialCallNode = null;
+    }
+
+    public override ICloneable Clone(ICloner cloner) {
+      CallGraph clone = (CallGraph)base.Clone(cloner);
+      foreach (ICallNode callNode in CallNodes)
+        clone.AddCallNode((ICallNode)cloner.Clone(callNode));
+      foreach (ICallNode source in CallNodes)
+        foreach (ICallNode target in transitions[source])
+          clone.AddTransition((ICallNode)cloner.Clone(source), (ICallNode)cloner.Clone(target));
+      clone.InitialCallNode = (ICallNode)cloner.Clone(InitialCallNode);
+
+      return base.Clone(cloner);
+    }
+
+    public override IView CreateView() {
+      return new CallGraphView(this);
+    }
+
+    internal void AddCallNode(ICallNode callNode) {
+      myCallNodes.Add(callNode);
+      transitions.Add(callNode, new List<ICallNode>());
+      OnCallNodeAdded(callNode);
+    }
+    public void RemoveCallNode(ICallNode callNode) {
+      if (myCallNodes.Remove(callNode)) {
+        foreach (ICallNode node in CallNodes) {  // remove incoming transitions
+          while (transitions[node].Contains(callNode))
+            RemoveTransition(node, callNode);
+        }
+        while (transitions[callNode].Count > 0)  // remove outgoing transitions
+          RemoveTransition(callNode, transitions[callNode][0]);
+        transitions.Remove(callNode);
+        OnCallNodeRemoved(callNode);
+      }
+    }
+
+    public void AddTransition(ICallNode source, ICallNode target) {
+      transitions[source].Add(target);
+      OnTransitionAdded(source, target);
+    }
+    public void RemoveTransition(ICallNode source, ICallNode target) {
+      if (transitions[source].Remove(target))
+        OnTransitionRemoved(source, target);
+    }
+
+    internal IList<ICallNode> GetSuccessorNodes(ICallNode callNode) {
+      return transitions[callNode].AsReadOnly();
+    }
+
+    public event EventHandler<EventArgs<ICallNode>> CallNodeAdded;
+    protected virtual void OnCallNodeAdded(ICallNode callNode) {
+      if (CallNodeAdded != null)
+        CallNodeAdded(this, new EventArgs<ICallNode>(callNode));
+    }
+    public event EventHandler<EventArgs<ICallNode>> CallNodeRemoved;
+    protected virtual void OnCallNodeRemoved(ICallNode callNode) {
+      if (CallNodeRemoved != null)
+        CallNodeRemoved(this, new EventArgs<ICallNode>(callNode));
+    }
+    public event EventHandler InitialCallNodeChanged;
+    protected virtual void OnInitialCallNodeChanged() {
+      if (InitialCallNodeChanged != null)
+        InitialCallNodeChanged(this, new EventArgs());
+    }
+    public event EventHandler<EventArgs<ICallNode, ICallNode>> TransistionAdded;
+    protected virtual void OnTransitionAdded(ICallNode source, ICallNode target) {
+      if (TransistionAdded != null)
+        TransistionAdded(this, new EventArgs<ICallNode,ICallNode>(source, target));
+    }
+    public event EventHandler<EventArgs<ICallNode, ICallNode>> TransistionRemoved;
+    protected virtual void OnTransitionRemoved(ICallNode source, ICallNode target) {
+      if (TransistionRemoved != null)
+        TransistionRemoved(this, new EventArgs<ICallNode, ICallNode>(source, target));
+    }
   }
 }

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Cloner.cs

@@ -46 +46 @@
 
     public ICloneable Clone(ICloneable obj) {
+      if (obj == null) return null;
       ICloneable clone;
       if (mapping.TryGetValue(obj, out clone))

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/EngineBase.cs

@@ -237 +237 @@
     /// Occurs when an operation is executed.
     /// </summary>
-    public event EventHandler<OperationEventArgs> OperationExecuted;
+    public event EventHandler<EventArgs<IOperation>> OperationExecuted;
     /// <summary>
     /// Fires a new <c>OperationExecuted</c> event.
@@ -244 +244 @@
     protected virtual void OnOperationExecuted(IOperation operation) {
       if (OperationExecuted != null)
-        OperationExecuted(this, new OperationEventArgs(operation));
+        OperationExecuted(this, new EventArgs<IOperation>(operation));
     }
     /// <summary>
     /// Occurs when an exception occured during the execution.
     /// </summary>
-    public event EventHandler<ExceptionEventArgs> ExceptionOccurred;
+    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;
     /// <summary>
     /// Aborts the execution and fires a new <c>ExceptionOccurred</c> event.
@@ -257 +257 @@
       Abort();
       if (ExceptionOccurred != null)
-        ExceptionOccurred(this, new ExceptionEventArgs(exception));
+        ExceptionOccurred(this, new EventArgs<Exception>(exception));
     }
     /// <summary>

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj

@@ -122 +122 @@
       <DependentUpon>ChooseTypeDialog.cs</DependentUpon>
     </Compile>
-    <Compile Include="AliasEventArgs.cs" />
     <Compile Include="CallGraph.cs" />
-    <Compile Include="CallNode.cs" />
+    <Compile Include="OperatorCallNode.cs" />
     <Compile Include="Cloner.cs" />
-    <Compile Include="ParameterEventArgs.cs" />
+    <Compile Include="CallGraphView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="CallGraphView.Designer.cs">
+      <DependentUpon>CallGraphView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="CancelEventArgs.cs" />
+    <Compile Include="CallNodeBase.cs" />
+    <Compile Include="EventArgs.cs" />
     <Compile Include="Interfaces\ICloner.cs" />
     <Compile Include="Interfaces\ICloneable.cs" />
@@ -140 +147 @@
     <Compile Include="Interfaces\ICallNode.cs" />
     <Compile Include="Interfaces\ICallGraph.cs" />
-    <Compile Include="KeyValueEventArgs.cs" />
     <Compile Include="OperatorBaseDescriptionView.cs">
       <SubType>UserControl</SubType>
@@ -150 +156 @@
     <Compile Include="Interfaces\IOperatorLibrary.cs" />
     <Compile Include="Interfaces\IVisualizationItem.cs" />
-    <Compile Include="NameChangingEventArgs.cs" />
-    <Compile Include="OperationEventArgs.cs" />
     <Compile Include="OperatorBaseVariablesView.cs">
       <SubType>UserControl</SubType>
@@ -164 +168 @@
       <DependentUpon>OperatorBaseVariableInfosView.cs</DependentUpon>
     </Compile>
-    <Compile Include="ExceptionEventArgs.cs" />
     <Compile Include="Interfaces\IItem.cs" />
     <Compile Include="ItemBase.cs" />
@@ -173 +176 @@
       <DependentUpon>ItemBaseView.cs</DependentUpon>
     </Compile>
-    <Compile Include="ItemEventArgs.cs" />
-    <Compile Include="ItemIndexEventArgs.cs" />
     <Compile Include="OperatorLibrary.cs" />
     <Compile Include="OperatorLibraryEditor.cs">
@@ -187 +188 @@
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
-    <Compile Include="ScopeIndexEventArgs.cs" />
     <Compile Include="EngineBaseEditor.cs">
       <SubType>UserControl</SubType>
@@ -194 +194 @@
       <DependentUpon>EngineBaseEditor.cs</DependentUpon>
     </Compile>
-    <Compile Include="VariableInfoEventArgs.cs" />
-    <Compile Include="VariableEventArgs.cs" />
     <Compile Include="Interfaces\IOperatorGroup.cs" />
     <Compile Include="Interfaces\IOperatorGraph.cs" />
@@ -201 +199 @@
     <Compile Include="Interfaces\IVariable.cs" />
     <Compile Include="Interfaces\IVariableInfo.cs" />
-    <Compile Include="OperatorEventArgs.cs" />
     <Compile Include="OperatorGroup.cs">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="OperatorIndexEventArgs.cs" />
-    <Compile Include="ScopeEventArgs.cs" />
     <Compile Include="OperatorBaseView.cs">
       <SubType>UserControl</SubType>
@@ -300 +295 @@
       <SubType>Designer</SubType>
     </EmbeddedResource>
+    <EmbeddedResource Include="CallGraphView.resx">
+      <DependentUpon>CallGraphView.cs</DependentUpon>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
     <EmbeddedResource Include="ParameterView.resx">
       <DependentUpon>ParameterView.cs</DependentUpon>

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/ICallGraph.cs

@@ -25 +25 @@
 
 namespace HeuristicLab.Core {
-  public interface ICallGraph : IItem {
+  public interface ICallGraph : ICallNode {
+    ICollection<ICallNode> CallNodes { get; }
+    ICallNode InitialCallNode { get; }
+
+    void RemoveCallNode(ICallNode callNode);
+
+    event EventHandler<EventArgs<ICallNode>> CallNodeAdded;
+    event EventHandler<EventArgs<ICallNode>> CallNodeRemoved;
+    event EventHandler InitialCallNodeChanged;
+
   }
 }

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/ICallNode.cs

@@ -26 +26 @@
 namespace HeuristicLab.Core {
   public interface ICallNode : IItem {
+    IEnumerable<KeyValuePair<string, string>> NameMappings { get; }
+    IList<ICallNode> SuccessorNodes { get; }
+    bool InitialCallNode { get; set; }
+
+    void AddNameMapping(string name, string alias);
+    void RemoveNameMapping(string name);
+    string MapName(string name);
+
+    event EventHandler<EventArgs<string, string>> NameMappingAdded;
+    event EventHandler<EventArgs<string, string>> NameMappingRemoved;
   }
 }

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IEngine.cs

@@ -87 +87 @@
     /// Occurs when an operation is executed.
     /// </summary>
-    event EventHandler<OperationEventArgs> OperationExecuted;
+    event EventHandler<EventArgs<IOperation>> OperationExecuted;
     /// <summary>
     /// Occurs when an exception was thrown.
     /// </summary>
-    event EventHandler<ExceptionEventArgs> ExceptionOccurred;
+    event EventHandler<EventArgs<Exception>> ExceptionOccurred;
     /// <summary>
     /// Occurs when the execution time was changed.

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IOperator.cs

@@ -92 +92 @@
     /// Occurs when a variable info has been added.
     /// </summary>
-    event EventHandler<ParameterEventArgs> ParameterAdded;
+    event EventHandler<EventArgs<IParameter>> ParameterAdded;
     /// <summary>
     /// Occurs when a variable info has been deleted.
     /// </summary>
-    event EventHandler<ParameterEventArgs> ParameterRemoved;
+    event EventHandler<EventArgs<IParameter>> ParameterRemoved;
     /// <summary>
     /// Occurs when the current instance is executed.

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IOperatorGraph.cs

@@ -57 +57 @@
     /// Occurs when a new operator has been added to the current instance.
     /// </summary>
-    event EventHandler<OperatorEventArgs> OperatorAdded;
+    event EventHandler<EventArgs<IOperator>> OperatorAdded;
     /// <summary>
     /// Occurs when an operator has been deleted from the current instance.
     /// </summary>
-    event EventHandler<OperatorEventArgs> OperatorRemoved;
+    event EventHandler<EventArgs<IOperator>> OperatorRemoved;
     /// <summary>
     /// Occurs when the initial operator (the starting one) has been changed.

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IParameter.cs

@@ -30 +30 @@
     Type DataType { get; }
     ParamterType Type { get; }
+    IItem Value { get; set; }
   }
 }

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IScope.cs

@@ -121 +121 @@
     /// Occurs when a variable has been added to the current instance.
     /// </summary>
-    event EventHandler<VariableEventArgs> VariableAdded;
+    event EventHandler<EventArgs<IVariable>> VariableAdded;
     /// <summary>
     /// Occurs when a variable has been deleted from the current instance.
     /// </summary>
-    event EventHandler<VariableEventArgs> VariableRemoved;
+    event EventHandler<EventArgs<IVariable>> VariableRemoved;
     /// <summary>
     /// Occurs when a sub scope has been added to the current instance.
     /// </summary>
-    event EventHandler<ScopeIndexEventArgs> SubScopeAdded;
+    event EventHandler<EventArgs<IScope, int>> SubScopeAdded;
     /// <summary>
     /// Occurs when a sub scope has been deleted from the current instance.
     /// </summary>
-    event EventHandler<ScopeIndexEventArgs> SubScopeRemoved;
+    event EventHandler<EventArgs<IScope, int>> SubScopeRemoved;
     /// <summary>
     /// Occurs when the sub scopes have been reordered.

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Interfaces/IVariable.cs

@@ -49 +49 @@
     /// Occurs when the name of the variable is currently changing.
     /// </summary>
-    event EventHandler<NameChangingEventArgs> NameChanging;
+    event EventHandler<CancelEventArgs<string>> NameChanging;
     /// <summary>
     /// Occurs when the name of the current instance has been changed.

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorBase.cs

@@ -186 +186 @@
     }
     /// <inheritdoc/>
-    public event EventHandler<ParameterEventArgs> ParameterAdded;
+    public event EventHandler<EventArgs<IParameter>> ParameterAdded;
     /// <summary>
     /// Fires a new <c>VariableInfoAdded</c> event.
@@ -193 +193 @@
     protected virtual void OnParameterAdded(IParameter parameter) {
       if (ParameterAdded != null)
-        ParameterAdded(this, new ParameterEventArgs(parameter));
-    }
-    /// <inheritdoc/>
-    public event EventHandler<ParameterEventArgs> ParameterRemoved;
+        ParameterAdded(this, new EventArgs<IParameter>(parameter));
+    }
+    /// <inheritdoc/>
+    public event EventHandler<EventArgs<IParameter>> ParameterRemoved;
     /// <summary>
     /// Fires a new <c>VariableInfoRemoved</c> event.
@@ -203 +203 @@
     protected virtual void OnParameterRemoved(IParameter parameter) {
       if (ParameterRemoved != null)
-        ParameterRemoved(this, new ParameterEventArgs(parameter));
+        ParameterRemoved(this, new EventArgs<IParameter>(parameter));
     }
     /// <inheritdoc/>

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/OperatorGraph.cs

@@ -127 +127 @@
 
     /// <inheritdoc/>
-    public event EventHandler<OperatorEventArgs> OperatorAdded;
+    public event EventHandler<EventArgs<IOperator>> OperatorAdded;
     /// <summary>
     /// Fires a new <c>OperatorAdded</c> event.
@@ -134 +134 @@
     protected virtual void OnOperatorAdded(IOperator op) {
       if (OperatorAdded != null)
-        OperatorAdded(this, new OperatorEventArgs(op));
+        OperatorAdded(this, new EventArgs<IOperator>(op));
     }
     /// <inheritdoc/>
-    public event EventHandler<OperatorEventArgs> OperatorRemoved;
+    public event EventHandler<EventArgs<IOperator>> OperatorRemoved;
     /// <summary>
     /// Fires a new <c>OperatorRemoved</c> event.
@@ -144 +144 @@
     protected virtual void OnOperatorRemoved(IOperator op) {
       if (OperatorRemoved != null)
-        OperatorRemoved(this, new OperatorEventArgs(op));
+        OperatorRemoved(this, new EventArgs<IOperator>(op));
     }
     /// <inheritdoc/>

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Scope.cs

@@ -238 +238 @@
 
     /// <inheritdoc />
-    public event EventHandler<VariableEventArgs> VariableAdded;
+    public event EventHandler<EventArgs<IVariable>> VariableAdded;
     /// <summary>
     /// Fires a new <c>VariableAdded</c> event.
@@ -245 +245 @@
     protected virtual void OnVariableAdded(IVariable variable) {
       if (VariableAdded != null)
-        VariableAdded(this, new VariableEventArgs(variable));
+        VariableAdded(this, new EventArgs<IVariable>(variable));
     }
     /// <inheritdoc />
-    public event EventHandler<VariableEventArgs> VariableRemoved;
+    public event EventHandler<EventArgs<IVariable>> VariableRemoved;
     /// <summary>
     /// Fires a new <c>VariableRemoved</c>.
@@ -255 +255 @@
     protected virtual void OnVariableRemoved(IVariable variable) {
       if (VariableRemoved != null)
-        VariableRemoved(this, new VariableEventArgs(variable));
-    }
-    /// <inheritdoc/>
-    public event EventHandler<ScopeIndexEventArgs> SubScopeAdded;
+        VariableRemoved(this, new EventArgs<IVariable>(variable));
+    }
+    /// <inheritdoc/>
+    public event EventHandler<EventArgs<IScope, int>> SubScopeAdded;
     /// <summary>
     /// Fires a new <c>SubScopeAdded</c> event.
@@ -266 +266 @@
     protected virtual void OnSubScopeAdded(IScope scope, int index) {
       if (SubScopeAdded != null)
-        SubScopeAdded(this, new ScopeIndexEventArgs(scope, index));
-    }
-    /// <inheritdoc/>
-    public event EventHandler<ScopeIndexEventArgs> SubScopeRemoved;
+        SubScopeAdded(this, new EventArgs<IScope,int>(scope, index));
+    }
+    /// <inheritdoc/>
+    public event EventHandler<EventArgs<IScope, int>> SubScopeRemoved;
     /// <summary>
     /// Fires a new <c>SubScopeRemoved</c> event.
@@ -277 +277 @@
     protected virtual void OnSubScopeRemoved(IScope scope, int index) {
       if (SubScopeRemoved != null)
-        SubScopeRemoved(this, new ScopeIndexEventArgs(scope, index));
+        SubScopeRemoved(this, new EventArgs<IScope,int>(scope, index));
     }
     /// <inheritdoc />

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/Variable.cs

@@ -41 +41 @@
       set {
         if (!myName.Equals(value)) {
-          NameChangingEventArgs e = new NameChangingEventArgs(value);
-          OnNameChanging(e);
-          if (!e.Cancel) {
+          if (! OnNameChanging(value).Cancel) {
             myName = value;
             OnNameChanged();
@@ -120 +118 @@
 
     /// <inheritdoc/>
-    public event EventHandler<NameChangingEventArgs> NameChanging;
+    public event EventHandler<CancelEventArgs<string>> NameChanging;
     /// <summary>
     /// Fires a new <c>NameChanging</c> event.
     /// </summary>
     /// <param name="e">The event arguments of the changing.</param>
-    protected virtual void OnNameChanging(NameChangingEventArgs e) {
+    protected virtual CancelEventArgs<string> OnNameChanging(string name) {
+      CancelEventArgs<string> eventArgs = new CancelEventArgs<string>(name);
       if (NameChanging != null)
-        NameChanging(this, e);
+        NameChanging(this, eventArgs);
+      return eventArgs;
     }
     /// <inheritdoc/>