Changeset 11564 for branches/OptimizationNetworks/HeuristicLab.Optimization.Networks/3.3/Core.Networks/ProgrammableNode.cs

Timestamp:

11/23/14 05:32:41 (9 years ago)

Author:

swagner

Message:

#2205: Continued working on programmable network items

File:

• branches/OptimizationNetworks/HeuristicLab.Optimization.Networks/3.3/Core.Networks/ProgrammableNode.cs (modified) (5 diffs)

branches/OptimizationNetworks/HeuristicLab.Optimization.Networks/3.3/Core.Networks/ProgrammableNode.cs

@@ -27 +27 @@
 
 namespace HeuristicLab.Core.Networks {
-  [Item("ProgrammableNode", "A programmable node of a network.")]
+  [Item("ProgrammableNode", "Abstract base class for programmable nodes of a network.")]
   [StorableClass]
-  public class ProgrammableNode : ProgrammableNetworkItem, INode {
-    protected override string CodeTemplate {
-      get { return ReadCodeTemplate("HeuristicLab.Optimization.Networks.Core.Networks.ProgrammableNodeTemplate.cs"); }
-    }
-
+  public abstract class ProgrammableNode : ProgrammableNetworkItem, IProgrammableNode {
+    #region Node Members
     new public INetwork Parent {
-      get { return (INetwork)base.Parent; }
+      get { return CompiledNetworkItem.Parent; }
       set {
         // NOTE: never call setter directly as the Parent property is set by the network which contains the node
-        base.Parent = value;
+        CompiledNetworkItem.Parent = value;
       }
-    }
-    public override IEnumerable<INetworkItem> Children {
-      get { return base.Children.Concat(Ports.AsEnumerable<INetworkItem>()); }
     }
 
@@ -48 +42 @@
     private PortCollection ports;
     protected PortCollection Ports {
-      get { return ports; }
+      get { return CompiledNetworkItem.Ports; }
     }
     private ReadOnlyKeyedItemCollection<string, IPort> readOnlyPorts;
     IKeyedItemCollection<string, IPort> INode.Ports {
       get {
-        if (readOnlyPorts == null) readOnlyPorts = ports.AsReadOnly();
+        if (readOnlyPorts == null) readOnlyPorts = Ports.AsReadOnly();
         return readOnlyPorts;
       }
     }
+    #endregion
+
+    protected override string CodeTemplate {
+      get { return ReadCodeTemplate("HeuristicLab.Optimization.Networks.Core.Networks.ProgrammableNodeTemplate.cs"); }
+    }
+
+    new protected CompiledProgrammableNode CompiledNetworkItem {
+      get { return (CompiledProgrammableNode)base.CompiledNetworkItem; }
+    }
 
     [StorableConstructor]
-    private ProgrammableNode(bool deserializing) : base(deserializing) { }
-    private ProgrammableNode(ProgrammableNode original, Cloner cloner)
+    protected ProgrammableNode(bool deserializing) : base(deserializing) { }
+    protected ProgrammableNode(ProgrammableNode original, Cloner cloner)
       : base(original, cloner) {
-      ports = cloner.Clone(original.ports);
-      foreach (var p in Ports)
-        p.Parent = this;
+      // ports are cloned in CompiledProgrammableNode
       readOnlyPorts = null;
-      RegisterPortsEvents();
     }
-    public ProgrammableNode()
+    protected ProgrammableNode()
       : base("ProgrammableNode") {
       ports = new PortCollection();
       readOnlyPorts = null;
-      RegisterPortsEvents();
     }
-    public ProgrammableNode(string name)
+    protected ProgrammableNode(string name)
       : base(name) {
       ports = new PortCollection();
       readOnlyPorts = null;
-      RegisterPortsEvents();
     }
-    public ProgrammableNode(string name, string description)
+    protected ProgrammableNode(string name, string description)
       : base(name, description) {
       ports = new PortCollection();
       readOnlyPorts = null;
-      RegisterPortsEvents();
     }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      foreach (var p in Ports)
-        p.Parent = this;
-      RegisterPortsEvents();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ProgrammableNode(this, cloner);
-    }
-
-    #region Ports Events
-    protected virtual void RegisterPortsEvents() {
-      ports.ItemsAdded += Ports_ItemsAdded;
-      ports.ItemsRemoved += Ports_ItemsRemoved;
-      ports.ItemsReplaced += Ports_ItemsReplaced;
-      ports.CollectionReset += Ports_CollectionReset;
-    }
-    protected virtual void Ports_ItemsAdded(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
-      foreach (var p in e.Items)
-        p.Parent = this;
-    }
-    protected virtual void Ports_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
-      foreach (var p in e.Items)
-        p.Parent = null;
-    }
-    protected virtual void Ports_ItemsReplaced(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
-      foreach (var p in e.OldItems)
-        p.Parent = null;
-      foreach (var p in e.Items)
-        p.Parent = this;
-    }
-    protected virtual void Ports_CollectionReset(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
-      foreach (var p in e.OldItems)
-        p.Parent = null;
-      foreach (var p in e.Items)
-        p.Parent = this;
-    }
-    #endregion
 
     #region CompiledProgrammableNode
     [Item("CompiledProgrammableNode", "Abstract base class for compiled programmable nodes of a network.")]
     public abstract class CompiledProgrammableNode : CompiledProgrammableNetworkItem, INode {
-      protected new ProgrammableNode Context {
+      #region Node Members
+      new public INetwork Parent {
+        get { return (INetwork)base.Parent; }
+        set {
+          // NOTE: never call setter directly as the Parent property is set by the network which contains the node
+          base.Parent = value;
+        }
+      }
+      public override IEnumerable<INetworkItem> Children {
+        get { return base.Children.Concat(Ports.AsEnumerable<INetworkItem>()); }
+      }
+
+      public PortCollection Ports {
+        get { return Context.ports; }
+      }
+      IKeyedItemCollection<string, IPort> INode.Ports {
+        get { return Ports; }
+      }
+      #endregion
+
+      new protected ProgrammableNode Context {
         get { return (ProgrammableNode)base.Context; }
       }
@@ -136 +113 @@
       protected CompiledProgrammableNode(CompiledProgrammableNode original, Cloner cloner)
         : base(original, cloner) {
+        Context.ports = cloner.Clone(original.Context.ports);
       }
       protected CompiledProgrammableNode(ProgrammableNode context)
@@ -141 +119 @@
       }
 
-      #region INode Members
-      public new INetwork Parent {
-        get { return Context.Parent; }
-        set {
-          // NOTE: never call setter directly as the Parent property is set by the network which contains the node
-          Context.Parent = value;
+      protected virtual void MessagePort_MessageReceived(object sender, EventArgs<IMessage, CancellationToken> e) { }
+
+      #region Events
+      public override void RegisterEvents() {
+        base.RegisterEvents();
+        Ports.ItemsAdded += Ports_ItemsAdded;
+        Ports.ItemsRemoved += Ports_ItemsRemoved;
+        Ports.ItemsReplaced += Ports_ItemsReplaced;
+        Ports.CollectionReset += Ports_CollectionReset;
+        foreach (var p in Ports) {
+          p.Parent = this;
+          RegisterPortEvents(p);
         }
       }
-
-      public IKeyedItemCollection<string, IPort> Ports {
-        get { return Context.Ports; }
+      public override void DeregisterEvents() {
+        foreach (var p in Ports) {
+          DeregisterPortEvents(p);
+          p.Parent = null;
+        }
+        Ports.ItemsAdded -= Ports_ItemsAdded;
+        Ports.ItemsRemoved -= Ports_ItemsRemoved;
+        Ports.ItemsReplaced -= Ports_ItemsReplaced;
+        Ports.CollectionReset -= Ports_CollectionReset;
+        base.DeregisterEvents();
+      }
+      protected virtual void Ports_ItemsAdded(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
+        foreach (var p in e.Items) {
+          p.Parent = this;
+          RegisterPortEvents(p);
+        }
+      }
+      protected virtual void Ports_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
+        foreach (var p in e.Items) {
+          p.Parent = null;
+          DeregisterPortEvents(p);
+        }
+      }
+      protected virtual void Ports_ItemsReplaced(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
+        foreach (var p in e.OldItems) {
+          p.Parent = null;
+          DeregisterPortEvents(p);
+        }
+        foreach (var p in e.Items) {
+          p.Parent = this;
+          RegisterPortEvents(p);
+        }
+      }
+      protected virtual void Ports_CollectionReset(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
+        foreach (var p in e.OldItems) {
+          p.Parent = null;
+          DeregisterPortEvents(p);
+        }
+        foreach (var p in e.Items) {
+          p.Parent = this;
+          RegisterPortEvents(p);
+        }
       }
       #endregion
 
-      #region Context Events
-      protected override void RegisterContextEvents() {
-        base.RegisterContextEvents();
-        Context.Ports.ItemsAdded += Ports_ItemsAdded;
-        Context.Ports.ItemsRemoved += Ports_ItemsRemoved;
-        Context.Ports.ItemsReplaced += Ports_ItemsReplaced;
-        Context.Ports.CollectionReset += Ports_CollectionReset;
-        foreach (var p in Context.Ports)
-          RegisterPortEvents(p);
-      }
-      protected override void DeregisterContextEvents() {
-        foreach (var p in Context.Ports)
-          DeregisterPortEvents(p);
-        Context.Ports.ItemsAdded -= Ports_ItemsAdded;
-        Context.Ports.ItemsRemoved -= Ports_ItemsRemoved;
-        Context.Ports.ItemsReplaced -= Ports_ItemsReplaced;
-        Context.Ports.CollectionReset -= Ports_CollectionReset;
-        base.DeregisterContextEvents();
-      }
-      private void Ports_ItemsAdded(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
-        foreach (var p in e.Items)
-          RegisterPortEvents(p);
-      }
-      private void Ports_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
-        foreach (var p in e.Items)
-          DeregisterPortEvents(p);
-      }
-      private void Ports_ItemsReplaced(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
-        foreach (var p in e.OldItems)
-          DeregisterPortEvents(p);
-        foreach (var p in e.Items)
-          RegisterPortEvents(p);
-      }
-      private void Ports_CollectionReset(object sender, Collections.CollectionItemsChangedEventArgs<IPort> e) {
-        foreach (var p in e.OldItems)
-          DeregisterPortEvents(p);
-        foreach (var p in e.Items)
-          RegisterPortEvents(p);
-      }
+      #region Port Events
       protected virtual void RegisterPortEvents(IPort port) {
         var mp = port as IMessagePort;
@@ -204 +189 @@
           mp.MessageReceived -= MessagePort_MessageReceived;
       }
-      protected virtual void MessagePort_MessageReceived(object sender, EventArgs<IMessage, CancellationToken> e) { }
       #endregion
     }