Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
03/05/10 03:07:12 (14 years ago)
Author:
swagner
Message:

Operator architecture refactoring (#95)

  • replaced Changed in IItem by ToStringChanged
Location:
trunk/sources/HeuristicLab.Core/3.3
Files:
1 deleted
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj

    r2900 r2932  
    102102    <Compile Include="Cloner.cs" />
    103103    <Compile Include="Attributes\CreatableAttribute.cs" />
    104     <Compile Include="ChangedEventArgs.cs" />
    105104    <None Include="HeuristicLabCorePlugin.cs.frame" />
    106105    <Compile Include="Interfaces\IParameterizedNamedItem.cs" />

  • trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItem.cs

    r2852 r2932  
    2020#endregion
    2121
     22using System;
    2223using System.Drawing;
    2324
    … …  
    3132    Image ItemImage { get; }
    3233
    33     event ChangedEventHandler Changed;
     34    event EventHandler ToStringChanged;
    3435  }
    3536}

  • trunk/sources/HeuristicLab.Core/3.3/Item.cs

    r2830 r2932  
    2020#endregion
    2121
     22using System;
    2223using System.Drawing;
    2324using HeuristicLab.Common.Resources;
    … …  
    4950    }
    5051
    51     public event ChangedEventHandler Changed;
    52     protected void OnChanged() {
    53       OnChanged(new ChangedEventArgs());
    54     }
    55     protected virtual void OnChanged(ChangedEventArgs e) {
    56       if ((e.RegisterChangedObject(this)) && (Changed != null))
    57         Changed(this, e);
     52    public event EventHandler ToStringChanged;
     53    protected virtual void OnToStringChanged() {
     54      if (ToStringChanged != null)
     55        ToStringChanged(this, EventArgs.Empty);
    5856    }
    5957  }

  • trunk/sources/HeuristicLab.Core/3.3/ItemArray.cs

    r2833 r2932  
    3535  [Item("ItemArray<T>", "Represents an array of items.")]
    3636  public class ItemArray<T> : ObservableArray<T>, IItem where T : class, IItem {
    37     [Storable(Name = "RestoreEvents")]
    38     private object RestoreEvents {
    39       get { return null; }
    40       set {
    41         foreach (T item in this)
    42           if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    43       }
    44     }
    45 
    4637    public virtual string ItemName {
    4738      get { return ItemAttribute.GetName(this.GetType()); }
    … …  
    5647    public ItemArray() : base() { }
    5748    public ItemArray(int length) : base(length) { }
    58     public ItemArray(T[] array) : base(array) {
    59       foreach (T item in this)
    60         if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    61     }
    62     public ItemArray(IEnumerable<T> collection) : base(collection) {
    63       foreach (T item in this)
    64         if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    65     }
     49    public ItemArray(T[] array) : base(array) { }
     50    public ItemArray(IEnumerable<T> collection) : base(collection) { }
    6651
    6752    public object Clone() {
    … …  
    7964    }
    8065
    81     public event ChangedEventHandler Changed;
    82     protected void OnChanged() {
    83       OnChanged(new ChangedEventArgs());
    84     }
    85     protected virtual void OnChanged(ChangedEventArgs e) {
    86       if ((e.RegisterChangedObject(this)) && (Changed != null))
    87         Changed(this, e);
    88     }
    89 
    90     protected override void OnItemsReplaced(IEnumerable<IndexedItem<T>> items, IEnumerable<IndexedItem<T>> oldItems) {
    91       foreach (IndexedItem<T> oldItem in oldItems)
    92         if (oldItem.Value != null) oldItem.Value.Changed -= new ChangedEventHandler(Item_Changed);
    93       foreach (IndexedItem<T> item in items)
    94         if (item.Value != null) item.Value.Changed += new ChangedEventHandler(Item_Changed);
    95       base.OnItemsReplaced(items, oldItems);
    96     }
    97     protected override void OnCollectionReset(IEnumerable<IndexedItem<T>> items, IEnumerable<IndexedItem<T>> oldItems) {
    98       foreach (IndexedItem<T> oldItem in oldItems)
    99         if (oldItem.Value != null) oldItem.Value.Changed -= new ChangedEventHandler(Item_Changed);
    100       foreach (IndexedItem<T> item in items)
    101         if (item.Value != null) item.Value.Changed += new ChangedEventHandler(Item_Changed);
    102       base.OnCollectionReset(items, oldItems);
    103     }
    104     protected override void OnPropertyChanged(string propertyName) {
    105       base.OnPropertyChanged(propertyName);
    106       OnChanged();
    107     }
    108 
    109     private void Item_Changed(object sender, ChangedEventArgs e) {
    110       OnChanged(e);
     66    public event EventHandler ToStringChanged;
     67    protected virtual void OnToStringChanged() {
     68      if (ToStringChanged != null)
     69        ToStringChanged(this, EventArgs.Empty);
    11170    }
    11271  }

  • trunk/sources/HeuristicLab.Core/3.3/ItemCollection.cs

    r2852 r2932  
    3232  [Item("ItemCollection<T>", "Represents a collection of items.")]
    3333  public class ItemCollection<T> : ObservableCollection<T>, IItem where T : class, IItem {
    34     [Storable(Name = "RestoreEvents")]
    35     private object RestoreEvents {
    36       get { return null; }
    37       set {
    38         foreach (T item in this)
    39           if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    40       }
    41     }
    42 
    4334    public virtual string ItemName {
    4435      get { return ItemAttribute.GetName(this.GetType()); }
    … …  
    5344    public ItemCollection() : base() { }
    5445    public ItemCollection(int capacity) : base(capacity) { }
    55     public ItemCollection(IEnumerable<T> collection) : base(collection) {
    56       foreach (T item in this)
    57         if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    58     }
     46    public ItemCollection(IEnumerable<T> collection) : base(collection) { }
    5947
    6048    public object Clone() {
    … …  
    7260    }
    7361
    74     public event ChangedEventHandler Changed;
    75     protected void OnChanged() {
    76       OnChanged(new ChangedEventArgs());
    77     }
    78     protected virtual void OnChanged(ChangedEventArgs e) {
    79       if ((e.RegisterChangedObject(this)) && (Changed != null))
    80         Changed(this, e);
    81     }
    82 
    83     protected override void OnItemsAdded(IEnumerable<T> items) {
    84       foreach (T item in items)
    85         if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    86       base.OnItemsAdded(items);
    87     }
    88     protected override void OnItemsRemoved(IEnumerable<T> items) {
    89       foreach (T item in items)
    90         if (item != null) item.Changed -= new ChangedEventHandler(Item_Changed);
    91       base.OnItemsRemoved(items);
    92     }
    93     protected override void OnCollectionReset(IEnumerable<T> items, IEnumerable<T> oldItems) {
    94       foreach (T oldItem in oldItems)
    95         if (oldItem != null) oldItem.Changed -= new ChangedEventHandler(Item_Changed);
    96       foreach (T item in items)
    97         if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    98       base.OnCollectionReset(items, oldItems);
    99     }
    100     protected override void OnPropertyChanged(string propertyName) {
    101       base.OnPropertyChanged(propertyName);
    102       OnChanged();
    103     }
    104 
    105     private void Item_Changed(object sender, ChangedEventArgs e) {
    106       OnChanged(e);
     62    public event EventHandler ToStringChanged;
     63    protected virtual void OnToStringChanged() {
     64      if (ToStringChanged != null)
     65        ToStringChanged(this, EventArgs.Empty);
    10766    }
    10867  }

  • trunk/sources/HeuristicLab.Core/3.3/ItemList.cs

    r2833 r2932  
    3636  [Item("ItemList<T>", "Represents a list of items.")]
    3737  public class ItemList<T> : ObservableList<T>, IItem where T : class, IItem {
    38     [Storable(Name = "RestoreEvents")]
    39     private object RestoreEvents {
    40       get { return null; }
    41       set {
    42         foreach (T item in this)
    43           if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    44       }
    45     }
    46 
    4738    public virtual string ItemName {
    4839      get { return ItemAttribute.GetName(this.GetType()); }
    … …  
    5748    public ItemList() : base() { }
    5849    public ItemList(int capacity) : base(capacity) { }
    59     public ItemList(IEnumerable<T> collection) : base(collection) {
    60       foreach (T item in this)
    61         if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    62     }
     50    public ItemList(IEnumerable<T> collection) : base(collection) { }
    6351
    6452    public object Clone() {
    … …  
    7664    }
    7765
    78     public event ChangedEventHandler Changed;
    79     protected void OnChanged() {
    80       OnChanged(new ChangedEventArgs());
    81     }
    82     protected virtual void OnChanged(ChangedEventArgs e) {
    83       if ((e.RegisterChangedObject(this)) && (Changed != null))
    84         Changed(this, e);
    85     }
    86 
    87     protected override void OnItemsAdded(IEnumerable<IndexedItem<T>> items) {
    88       foreach (IndexedItem<T> item in items)
    89         if (item.Value != null) item.Value.Changed += new ChangedEventHandler(Item_Changed);
    90       base.OnItemsAdded(items);
    91     }
    92     protected override void OnItemsRemoved(IEnumerable<IndexedItem<T>> items) {
    93       foreach (IndexedItem<T> item in items)
    94         if (item.Value != null) item.Value.Changed -= new ChangedEventHandler(Item_Changed);
    95       base.OnItemsRemoved(items);
    96     }
    97     protected override void OnItemsReplaced(IEnumerable<IndexedItem<T>> items, IEnumerable<IndexedItem<T>> oldItems) {
    98       foreach (IndexedItem<T> oldItem in oldItems)
    99         if (oldItem.Value != null) oldItem.Value.Changed -= new ChangedEventHandler(Item_Changed);
    100       foreach (IndexedItem<T> item in items)
    101         if (item.Value != null) item.Value.Changed += new ChangedEventHandler(Item_Changed);
    102       base.OnItemsReplaced(items, oldItems);
    103     }
    104     protected override void OnCollectionReset(IEnumerable<IndexedItem<T>> items, IEnumerable<IndexedItem<T>> oldItems) {
    105       foreach (IndexedItem<T> oldItem in oldItems)
    106         if (oldItem.Value != null) oldItem.Value.Changed -= new ChangedEventHandler(Item_Changed);
    107       foreach (IndexedItem<T> item in items)
    108         if (item.Value != null) item.Value.Changed += new ChangedEventHandler(Item_Changed);
    109       base.OnCollectionReset(items, oldItems);
    110     }
    111     protected override void OnPropertyChanged(string propertyName) {
    112       base.OnPropertyChanged(propertyName);
    113       OnChanged();
    114     }
    115 
    116     private void Item_Changed(object sender, ChangedEventArgs e) {
    117       OnChanged(e);
     66    public event EventHandler ToStringChanged;
     67    protected virtual void OnToStringChanged() {
     68      if (ToStringChanged != null)
     69        ToStringChanged(this, EventArgs.Empty);
    11870    }
    11971  }

  • trunk/sources/HeuristicLab.Core/3.3/ItemSet.cs

    r2833 r2932  
    3636  [Item("ItemSet<T>", "Represents a set of items.")]
    3737  public class ItemSet<T> : ObservableSet<T>, IItem where T : class, IItem {
    38     [Storable(Name = "RestoreEvents")]
    39     private object RestoreEvents {
    40       get { return null; }
    41       set {
    42         foreach (T item in this)
    43           if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    44       }
    45     }
    46 
    4738    public virtual string ItemName {
    4839      get { return ItemAttribute.GetName(this.GetType()); }
    … …  
    5647
    5748    public ItemSet() : base() { }
    58     public ItemSet(IEnumerable<T> collection) : base(collection) {
    59       foreach (T item in this)
    60         if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    61     }
     49    public ItemSet(IEnumerable<T> collection) : base(collection) { }
    6250
    6351    public object Clone() {
    … …  
    7563    }
    7664
    77     public event ChangedEventHandler Changed;
    78     protected void OnChanged() {
    79       OnChanged(new ChangedEventArgs());
    80     }
    81     protected virtual void OnChanged(ChangedEventArgs e) {
    82       if ((e.RegisterChangedObject(this)) && (Changed != null))
    83         Changed(this, e);
    84     }
    85 
    86     protected override void OnItemsAdded(IEnumerable<T> items) {
    87       foreach (T item in items)
    88         if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    89       base.OnItemsAdded(items);
    90     }
    91     protected override void OnItemsRemoved(IEnumerable<T> items) {
    92       foreach (T item in items)
    93         if (item != null) item.Changed -= new ChangedEventHandler(Item_Changed);
    94       base.OnItemsRemoved(items);
    95     }
    96     protected override void OnCollectionReset(IEnumerable<T> items, IEnumerable<T> oldItems) {
    97       foreach (T oldItem in oldItems)
    98         if (oldItem != null) oldItem.Changed -= new ChangedEventHandler(Item_Changed);
    99       foreach (T item in items)
    100         if (item != null) item.Changed += new ChangedEventHandler(Item_Changed);
    101       base.OnCollectionReset(items, oldItems);
    102     }
    103     protected override void OnPropertyChanged(string propertyName) {
    104       base.OnPropertyChanged(propertyName);
    105       OnChanged();
    106     }
    107 
    108     private void Item_Changed(object sender, ChangedEventArgs e) {
    109       OnChanged(e);
     65    public event EventHandler ToStringChanged;
     66    protected virtual void OnToStringChanged() {
     67      if (ToStringChanged != null)
     68        ToStringChanged(this, EventArgs.Empty);
    11069    }
    11170  }

  • trunk/sources/HeuristicLab.Core/3.3/NamedItem.cs

    r2931 r2932  
    130130      if (NameChanged != null)
    131131        NameChanged(this, EventArgs.Empty);
    132       OnChanged();
     132      OnToStringChanged();
    133133    }
    134134    /// <inheritdoc/>
    … …  
    141141      if (DescriptionChanged != null)
    142142        DescriptionChanged(this, EventArgs.Empty);
    143       OnChanged();
    144143    }
    145144  }

  • trunk/sources/HeuristicLab.Core/3.3/NamedItemCollection.cs

    r2834 r2932  
    6666    }
    6767
    68     public event ChangedEventHandler Changed;
    69     protected void OnChanged() {
    70       OnChanged(new ChangedEventArgs());
    71     }
    72     protected virtual void OnChanged(ChangedEventArgs e) {
    73       if ((e.RegisterChangedObject(this)) && (Changed != null))
    74         Changed(this, e);
     68    public event EventHandler ToStringChanged;
     69    protected virtual void OnToStringChanged() {
     70      if (ToStringChanged != null)
     71        ToStringChanged(this, EventArgs.Empty);
    7572    }
    7673
    … …  
    9895      base.OnCollectionReset(items, oldItems);
    9996    }
    100     protected override void OnPropertyChanged(string propertyName) {
    101       base.OnPropertyChanged(propertyName);
    102       OnChanged();
    103     }
    10497
    10598    private void RegisterItemEvents(IEnumerable<T> items) {
    … …  
    108101          item.NameChanging += new EventHandler<CancelEventArgs<string>>(Item_NameChanging);
    109102          item.NameChanged += new EventHandler(Item_NameChanged);
    110           item.Changed += new ChangedEventHandler(Item_Changed);
    111103        }
    112104      }
    … …  
    117109          item.NameChanging -= new EventHandler<CancelEventArgs<string>>(Item_NameChanging);
    118110          item.NameChanged -= new EventHandler(Item_NameChanged);
    119           item.Changed -= new ChangedEventHandler(Item_Changed);
    120111        }
    121112      }
    … …  
    129120      UpdateItemKey(item);
    130121    }
    131     private void Item_Changed(object sender, ChangedEventArgs e) {
    132       OnChanged(e);
    133     }
    134122  }
    135123}

  • trunk/sources/HeuristicLab.Core/3.3/OperatorGraph.cs

    r2853 r2932  
    114114      if (InitialOperatorChanged != null)
    115115        InitialOperatorChanged(this, EventArgs.Empty);
    116       OnChanged();
    117116    }
    118117
    … …  
    153152    private void RegisterOperatorsEvents() {
    154153      if (operators != null) {
    155         operators.Changed += new ChangedEventHandler(Operators_Changed);
    156154        operators.ItemsAdded += new CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsAdded);
    157155        operators.ItemsRemoved += new CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsRemoved);
    … …  
    175173          DeregisterOperatorEvents(op);
    176174        }
    177         operators.Changed -= new ChangedEventHandler(Operators_Changed);
    178175        operators.ItemsAdded -= new CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsAdded);
    179176        operators.ItemsRemoved -= new CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsRemoved);
    … …  
    240237      if (opParam.Value != null) Operators.Add(opParam.Value);
    241238    }
    242     private void Operators_Changed(object sender, ChangedEventArgs e) {
    243       OnChanged(e);
    244     }
    245239    #endregion
    246240  }

  • trunk/sources/HeuristicLab.Core/3.3/ParameterizedNamedItem.cs

    r2851 r2932  
    3434      get { return parameters; }
    3535      private set {
    36         if (parameters != null) parameters.Changed -= new ChangedEventHandler(Parameters_Changed);
    3736        parameters = value;
    3837        readOnlyParameters = null;
    39         if (parameters != null) parameters.Changed += new ChangedEventHandler(Parameters_Changed);
    4038      }
    4139    }
    … …  
    8381      return clone;
    8482    }
    85 
    86     private void Parameters_Changed(object sender, ChangedEventArgs e) {
    87       OnChanged(e);
    88     }
    8983  }
    9084}

  • trunk/sources/HeuristicLab.Core/3.3/Scope.cs

    r2931 r2932  
    4141    }
    4242
     43    [Storable]
    4344    private VariableCollection variables;
    44     [Storable]
    4545    public VariableCollection Variables {
    4646      get { return variables; }
    47       private set {
    48         if (variables != null) variables.Changed -= new ChangedEventHandler(Variables_Changed);
    49         variables = value;
    50         if (variables != null) variables.Changed += new ChangedEventHandler(Variables_Changed);
    51       }
    5247    }
    5348
    … …  
    6964      : base("Anonymous") {
    7065      parent = null;
    71       Variables = new VariableCollection();
     66      variables = new VariableCollection();
    7267      SubScopes = new ScopeList();
    7368    }
    … …  
    7974      : base(name) {
    8075      parent = null;
    81       Variables = new VariableCollection();
     76      variables = new VariableCollection();
    8277      SubScopes = new ScopeList();
    8378    }
    … …  
    8580      : base(name, description) {
    8681      parent = null;
    87       Variables = new VariableCollection();
     82      variables = new VariableCollection();
    8883      SubScopes = new ScopeList();
    8984    }
    … …  
    10196      clone.Name = Name;
    10297      clone.Description = Description;
    103       if (variables.Count > 0) clone.Variables = (VariableCollection)cloner.Clone(variables);
     98      if (variables.Count > 0) clone.variables = (VariableCollection)cloner.Clone(variables);
    10499      if (subScopes.Count > 0) clone.SubScopes = (ScopeList)cloner.Clone(subScopes);
    105100      return clone;
    … …  
    113108        subScopes.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsReplaced);
    114109        subScopes.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_CollectionReset);
    115         subScopes.Changed += new ChangedEventHandler(SubScopes_Changed);
    116110      }
    117111    }
    … …  
    122116        subScopes.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsReplaced);
    123117        subScopes.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_CollectionReset);
    124         subScopes.Changed -= new ChangedEventHandler(SubScopes_Changed);
    125118      }
    126119    }
    … …  
    145138        item.Value.Parent = this;
    146139    }
    147     private void SubScopes_Changed(object sender, ChangedEventArgs e) {
    148       OnChanged(e);
    149     }
    150     #endregion
    151 
    152     #region Variables Events
    153     private void Variables_Changed(object sender, ChangedEventArgs e) {
    154       OnChanged(e);
    155     }
    156140    #endregion
    157141  }

  • trunk/sources/HeuristicLab.Core/3.3/Variable.cs

    r2833 r2932  
    3939      set {
    4040        if (this.value != value) {
    41           if (this.value != null) this.value.Changed -= new ChangedEventHandler(Value_Changed);
     41          if (this.value != null) this.value.ToStringChanged -= new EventHandler(Value_ToStringChanged);
    4242          this.value = value;
    43           if (this.value != null) this.value.Changed += new ChangedEventHandler(Value_Changed);
     43          if (this.value != null) this.value.ToStringChanged += new EventHandler(Value_ToStringChanged);
    4444          OnValueChanged();
    4545        }
    … …  
    7272      : base(name) {
    7373      this.value = value;
    74       if (this.value != null) this.value.Changed += new ChangedEventHandler(Value_Changed);
     74      if (this.value != null) this.value.ToStringChanged += new EventHandler(Value_ToStringChanged);
    7575    }
    7676    public Variable(string name, string description, IItem value)
    7777      : base(name, description) {
    7878      this.value = value;
    79       if (this.value != null) this.value.Changed += new ChangedEventHandler(Value_Changed);
     79      if (this.value != null) this.value.ToStringChanged += new EventHandler(Value_ToStringChanged);
    8080    }
    8181
    … …  
    110110      if (ValueChanged != null)
    111111        ValueChanged(this, EventArgs.Empty);
    112       OnChanged();
    113112    }
    114113
    115     private void Value_Changed(object sender, ChangedEventArgs e) {
    116       OnChanged(e);
     114    private void Value_ToStringChanged(object sender, EventArgs e) {
     115      OnToStringChanged();
    117116    }
    118117  }
Note: See TracChangeset for help on using the changeset viewer.