Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
01/20/10 05:00:28 (14 years ago)
Author:
swagner
Message:

Committing first results of the refactoring of HeuristicLab.Core and related plugins (#95)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Core/3.3/OperatorGraph.cs

    r2526 r2653  
    2424using System.Text;
    2525using System.Xml;
     26using System.Linq;
    2627using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2728using HeuristicLab.Common;
     29using HeuristicLab.Collections;
    2830
    2931namespace HeuristicLab.Core {
     
    3133  /// Represents a graph of operators.
    3234  /// </summary>
    33   public class OperatorGraph : ItemBase, IOperatorGraph {
    34 
     35  [Item("OperatorGraph", "Represents a graph of operators.")]
     36  [Creatable("Test")]
     37  public class OperatorGraph : ItemBase {
     38    private OperatorSet operators;
     39    /// <summary>
     40    /// Gets all operators of the current instance.
     41    /// </summary>
    3542    [Storable]
    36     private IDictionary<IOperator, IOperator> myOperators;
    37     /// <summary>
    38     /// Gets all operators of the current instance.
    39     /// </summary>
    40     public ICollection<IOperator> Operators {
    41       get { return myOperators.Values; }
     43    public OperatorSet Operators {
     44      get { return operators; }
     45      private set {
     46        DeregisterOperatorsEvents();
     47        operators = value;
     48        RegisterOperatorsEvents();
     49      }
    4250    }
    4351
    4452    [Storable]
    45     private IOperator myInitialOperator;
     53    private IOperator initialOperator;
    4654    /// <summary>
    4755    /// Gets or sets the initial operator (the starting one).
     
    4957    /// <remarks>Calls <see cref="OnInitialOperatorChanged"/> in the setter.</remarks>
    5058    public IOperator InitialOperator {
    51       get { return myInitialOperator; }
     59      get { return initialOperator; }
    5260      set {
    53         if (myInitialOperator != value) {
    54           myInitialOperator = value;
     61        if (initialOperator != value) {
     62          if (value != null) Operators.Add(value);
     63          initialOperator = value;
    5564          OnInitialOperatorChanged();
    5665        }
     
    6271    /// </summary>
    6372    public OperatorGraph() {
    64       myOperators = new Dictionary<IOperator, IOperator>();
     73      Operators = new OperatorSet();
     74      initialOperator = null;
    6575    }
    6676
     
    7282    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
    7383    /// <returns>The cloned object as <see cref="OperatorGraph"/>.</returns>
    74     public override IItem Clone(ICloner cloner) {
     84    public override IDeepCloneable Clone(Cloner cloner) {
    7585      OperatorGraph clone = new OperatorGraph();
    7686      cloner.RegisterClonedObject(this, clone);
    77       foreach (IOperator op in Operators)
    78         clone.AddOperator((IOperator)cloner.Clone(op));
    79       if (InitialOperator != null)
    80         clone.myInitialOperator = (IOperator)cloner.Clone(InitialOperator);
     87      clone.Operators = (OperatorSet)cloner.Clone(operators);
     88      clone.initialOperator = (IOperator)cloner.Clone(initialOperator);
    8189      return clone;
    8290    }
    8391
    84     /// <inheritdoc/>
    85     /// <remarks>Calls <see cref="OnOperatorAdded"/>.</remarks>
    86     public void AddOperator(IOperator op) {
    87       if (!myOperators.ContainsKey(op)) {
    88         myOperators.Add(op, op);
    89         OnOperatorAdded(op);
    90 
    91         foreach (IOperator subOperator in op.SubOperators)
    92           AddOperator(subOperator);
    93       }
    94     }
    95     /// <inheritdoc/>
    96     /// <remarks>Calls <see cref="OnOperatorRemoved"/>.</remarks>
    97     public void RemoveOperator(IOperator op) {
    98       if (myOperators.ContainsKey(op)) {
    99         foreach (IOperator o in Operators) {
    100           int i = 0;
    101           while (i < o.SubOperators.Count) {
    102             if (o.SubOperators[i] == op)
    103               o.RemoveSubOperator(i);
    104             else
    105               i++;
    106           }
    107         }
    108         if (InitialOperator == op)
    109           InitialOperator = null;
    110         myOperators.Remove(op);
    111         OnOperatorRemoved(op);
    112       }
    113     }
    114     /// <inheritdoc/>
    115     public void Clear() {
    116       IOperator[] ops = new IOperator[Operators.Count];
    117       int i = 0;
    118       foreach (IOperator op in Operators) {
    119         ops[i] = op;
    120         i++;
    121       }
    122       for (int j = 0; j < ops.Length; j++)
    123         RemoveOperator(ops[j]);
    124     }
    125 
    126     /// <inheritdoc/>
    127     public event EventHandler<EventArgs<IOperator>> OperatorAdded;
    128     /// <summary>
    129     /// Fires a new <c>OperatorAdded</c> event.
    130     /// </summary>
    131     /// <param name="op">The operator that has been added.</param>
    132     protected virtual void OnOperatorAdded(IOperator op) {
    133       if (OperatorAdded != null)
    134         OperatorAdded(this, new EventArgs<IOperator>(op));
    135     }
    136     /// <inheritdoc/>
    137     public event EventHandler<EventArgs<IOperator>> OperatorRemoved;
    138     /// <summary>
    139     /// Fires a new <c>OperatorRemoved</c> event.
    140     /// </summary>
    141     /// <param name="op">The operator that has been removed.</param>
    142     protected virtual void OnOperatorRemoved(IOperator op) {
    143       if (OperatorRemoved != null)
    144         OperatorRemoved(this, new EventArgs<IOperator>(op));
    145     }
    14692    /// <inheritdoc/>
    14793    public event EventHandler InitialOperatorChanged;
     
    15298      if (InitialOperatorChanged != null)
    15399        InitialOperatorChanged(this, new EventArgs());
    154     }
     100      OnChanged();
     101    }
     102
     103    #region Operators Events
     104    private void AddOperator(IOperator op) {
     105      RegisterOperatorEvents(op);
     106      foreach (IParameter param in op.Parameters)
     107        AddParameter(param);
     108    }
     109    private void RemoveOperator(IOperator op) {
     110      foreach (IParameter param in op.Parameters)
     111        RemoveParameter(param);
     112      DeregisterOperatorEvents(op);
     113
     114      // remove edges to removed operator
     115      var opParams = from o in Operators
     116                     from p in o.Parameters
     117                     where p is IOperatorParameter
     118                     where (((IOperatorParameter)p).Value != null) && (((IOperatorParameter)p).Value == op)
     119                     select (IOperatorParameter)p;
     120      foreach (IOperatorParameter opParam in opParams)
     121        opParam.Value = null;
     122    }
     123    private void AddParameter(IParameter param) {
     124      IOperatorParameter opParam = param as IOperatorParameter;
     125      if (opParam != null) {
     126        RegisterOperatorParameterEvents(opParam);
     127        if (opParam.Value != null) Operators.Add(opParam.Value);
     128      }
     129    }
     130    private void RemoveParameter(IParameter param) {
     131      IOperatorParameter opParam = param as IOperatorParameter;
     132      if (opParam != null) {
     133        DeregisterOperatorParameterEvents(opParam);
     134      }
     135    }
     136
     137    private void RegisterOperatorsEvents() {
     138      if (operators != null) {
     139        operators.Changed += new ChangedEventHandler(Operators_Changed);
     140        operators.ItemsAdded += new CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsAdded);
     141        operators.ItemsRemoved += new CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsRemoved);
     142        operators.CollectionReset += new CollectionItemsChangedEventHandler<IOperator>(Operators_CollectionReset);
     143      }
     144    }
     145    private void DeregisterOperatorsEvents() {
     146      if (operators != null) {
     147        operators.Changed -= new ChangedEventHandler(Operators_Changed);
     148        operators.ItemsAdded -= new CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsAdded);
     149        operators.ItemsRemoved -= new CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsRemoved);
     150        operators.CollectionReset -= new CollectionItemsChangedEventHandler<IOperator>(Operators_CollectionReset);
     151      }
     152    }
     153    private void RegisterOperatorEvents(IOperator op) {
     154      op.Parameters.ItemsAdded += new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsAdded);
     155      op.Parameters.ItemsRemoved += new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsRemoved);
     156      op.Parameters.ItemsReplaced += new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsReplaced);
     157      op.Parameters.CollectionReset += new CollectionItemsChangedEventHandler<IParameter>(Parameters_CollectionReset);
     158    }
     159    private void DeregisterOperatorEvents(IOperator op) {
     160      op.Parameters.ItemsAdded -= new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsAdded);
     161      op.Parameters.ItemsRemoved -= new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsRemoved);
     162      op.Parameters.ItemsReplaced -= new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsReplaced);
     163      op.Parameters.CollectionReset -= new CollectionItemsChangedEventHandler<IParameter>(Parameters_CollectionReset);
     164    }
     165    private void RegisterOperatorParameterEvents(IOperatorParameter opParam) {
     166      opParam.ValueChanged += new EventHandler(opParam_ValueChanged);
     167    }
     168    private void DeregisterOperatorParameterEvents(IOperatorParameter opParam) {
     169      opParam.ValueChanged -= new EventHandler(opParam_ValueChanged);
     170    }
     171
     172    private void Operators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IOperator> e) {
     173      foreach (IOperator op in e.Items)
     174        AddOperator(op);
     175    }
     176    private void Operators_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IOperator> e) {
     177      foreach (IOperator op in e.Items)
     178        RemoveOperator(op);
     179      if (!Operators.Contains(InitialOperator)) InitialOperator = null;
     180    }
     181    private void Operators_CollectionReset(object sender, CollectionItemsChangedEventArgs<IOperator> e) {
     182      foreach (IOperator op in e.OldItems)
     183        RemoveOperator(op);
     184      foreach (IOperator op in e.Items)
     185        AddOperator(op);
     186      if (!Operators.Contains(InitialOperator)) InitialOperator = null;
     187    }
     188    private void Parameters_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
     189      foreach (IParameter param in e.Items)
     190        AddParameter(param);
     191    }
     192    private void Parameters_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
     193      foreach (IParameter param in e.Items)
     194        RemoveParameter(param);
     195    }
     196    private void Parameters_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
     197      foreach (IParameter param in e.OldItems)
     198        RemoveParameter(param);
     199      foreach (IParameter param in e.Items)
     200        AddParameter(param);
     201    }
     202    private void Parameters_CollectionReset(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
     203      foreach (IParameter param in e.OldItems)
     204        RemoveParameter(param);
     205      foreach (IParameter param in e.Items)
     206        AddParameter(param);
     207    }
     208    private void opParam_ValueChanged(object sender, EventArgs e) {
     209      IOperatorParameter opParam = (IOperatorParameter)sender;
     210      if (opParam.Value != null) Operators.Add(opParam.Value);
     211    }
     212    private void Operators_Changed(object sender, ChangedEventArgs e) {
     213      OnChanged(e);
     214    }
     215    #endregion
    155216  }
    156217}
Note: See TracChangeset for help on using the changeset viewer.