Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
04/18/10 02:27:02 (14 years ago)
Author:
swagner
Message:

Refactored HeuristicLab.Collections (#977)

Location:
trunk/sources/HeuristicLab.Core/3.3
Files:
15 added
1 edited
13 moved

Legend:

Unmodified
Added
Removed

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

    r3381 r3390  
    3535  [StorableClass]
    3636  [Item("ItemArray<T>", "Represents an array of items.")]
    37   public class ItemArray<T> : ObservableArray<T>, IItem where T : class, IItem {
     37  public class ItemArray<T> : ObservableArray<T>, IItemArray<T> where T : class, IItem {
    3838    public virtual string ItemName {
    3939      get { return ItemAttribute.GetName(this.GetType()); }
    … …  
    4646    }
    4747
    48     public ItemArray() : base() { }
    49     public ItemArray(int length) : base(length) { }
    50     public ItemArray(T[] array) : base(array) { }
    51     public ItemArray(IEnumerable<T> collection) : base(collection) { }
     48    [Storable]
     49    private T[] Items {
     50      get { return array; }
     51      set { array = value; }
     52    }
     53
     54    [Storable]
     55    private bool readOnlyView;
     56    public virtual bool ReadOnlyView {
     57      get { return readOnlyView; }
     58      set {
     59        if ((readOnlyView != value) && !(array.IsReadOnly)) {
     60          readOnlyView = value;
     61          OnReadOnlyViewChanged();
     62          OnPropertyChanged("ReadOnlyView");
     63        }
     64      }
     65    }
     66
     67    public ItemArray()
     68      : base() {
     69      readOnlyView = array.IsReadOnly;
     70    }
     71    public ItemArray(int length)
     72      : base(length) {
     73      readOnlyView = array.IsReadOnly;
     74    }
     75    public ItemArray(T[] array)
     76      : base(array) {
     77      readOnlyView = array.IsReadOnly;
     78    }
     79    public ItemArray(IEnumerable<T> collection)
     80      : base(collection) {
     81      readOnlyView = array.IsReadOnly;
     82    }
     83    [StorableConstructor]
     84    protected ItemArray(bool deserializing) { }
    5285
    5386    public object Clone() {
    5487      return Clone(new Cloner());
    5588    }
    56 
    5789    public virtual IDeepCloneable Clone(Cloner cloner) {
    5890      ItemArray<T> clone = (ItemArray<T>)Activator.CreateInstance(this.GetType());
    5991      cloner.RegisterClonedObject(this, clone);
    60       clone.ReadOnlyView = ReadOnlyView;
     92      clone.readOnlyView = readOnlyView;
    6193      clone.array = this.Select(x => (T)cloner.Clone(x)).ToArray();
    6294      return clone;
     95    }
     96
     97    public new ReadOnlyItemArray<T> AsReadOnly() {
     98      return new ReadOnlyItemArray<T>(this);
    6399    }
    64100
    … …  
    77113      if (handler != null) handler(this, EventArgs.Empty);
    78114    }
     115    public event EventHandler ReadOnlyViewChanged;
     116    protected virtual void OnReadOnlyViewChanged() {
     117      EventHandler handler = ReadOnlyViewChanged;
     118      if (handler != null) handler(this, EventArgs.Empty);
     119    }
    79120  }
    80121}

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

    r3381 r3390  
    3232  [StorableClass]
    3333  [Item("ItemCollection<T>", "Represents a collection of items.")]
    34   public class ItemCollection<T> : ObservableCollection<T>, IItem where T : class, IItem {
     34  public class ItemCollection<T> : ObservableCollection<T>, IItemCollection<T> where T : class, IItem {
    3535    public virtual string ItemName {
    3636      get { return ItemAttribute.GetName(this.GetType()); }
    … …  
    4343    }
    4444
    45     public ItemCollection() : base() { }
    46     public ItemCollection(int capacity) : base(capacity) { }
    47     public ItemCollection(IEnumerable<T> collection) : base(collection) { }
     45    [Storable]
     46    private List<T> Items {
     47      get { return list; }
     48      set { list = value; }
     49    }
     50
     51    [Storable]
     52    private bool readOnlyView;
     53    public virtual bool ReadOnlyView {
     54      get { return readOnlyView; }
     55      set {
     56        if ((readOnlyView != value) && !((ICollection<T>)list).IsReadOnly) {
     57          readOnlyView = value;
     58          OnReadOnlyViewChanged();
     59          OnPropertyChanged("ReadOnlyView");
     60        }
     61      }
     62    }
     63
     64    public ItemCollection()
     65      : base() {
     66      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     67    }
     68    public ItemCollection(int capacity)
     69      : base(capacity) {
     70      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     71    }
     72    public ItemCollection(IEnumerable<T> collection)
     73      : base(collection) {
     74      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     75    }
     76    [StorableConstructor]
     77    protected ItemCollection(bool deserializing) { }
    4878
    4979    public object Clone() {
    5080      return Clone(new Cloner());
    5181    }
    52 
    5382    public virtual IDeepCloneable Clone(Cloner cloner) {
    5483      ItemCollection<T> clone = (ItemCollection<T>)Activator.CreateInstance(this.GetType());
    5584      cloner.RegisterClonedObject(this, clone);
    56       clone.ReadOnlyView = ReadOnlyView;
     85      clone.readOnlyView = readOnlyView;
    5786      clone.list = new List<T>(this.Select(x => (T)cloner.Clone(x)));
    5887      return clone;
     88    }
     89
     90    public new ReadOnlyItemCollection<T> AsReadOnly() {
     91      return new ReadOnlyItemCollection<T>(this);
    5992    }
    6093
    … …  
    73106      if (handler != null) handler(this, EventArgs.Empty);
    74107    }
     108    public event EventHandler ReadOnlyViewChanged;
     109    protected virtual void OnReadOnlyViewChanged() {
     110      EventHandler handler = ReadOnlyViewChanged;
     111      if (handler != null) handler(this, EventArgs.Empty);
     112    }
    75113  }
    76114}

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

    r3381 r3390  
    3535  [StorableClass]
    3636  [Item("ItemList<T>", "Represents a list of items.")]
    37   public class ItemList<T> : ObservableList<T>, IItem where T : class, IItem {
     37  public class ItemList<T> : ObservableList<T>, IItemList<T> where T : class, IItem {
    3838    public virtual string ItemName {
    3939      get { return ItemAttribute.GetName(this.GetType()); }
    … …  
    4646    }
    4747
    48     public ItemList() : base() { }
    49     public ItemList(int capacity) : base(capacity) { }
    50     public ItemList(IEnumerable<T> collection) : base(collection) { }
     48    [Storable]
     49    private List<T> Items {
     50      get { return list; }
     51      set { list = value; }
     52    }
     53
     54    [Storable]
     55    private bool readOnlyView;
     56    public virtual bool ReadOnlyView {
     57      get { return readOnlyView; }
     58      set {
     59        if ((readOnlyView != value) && !((ICollection<T>)list).IsReadOnly) {
     60          readOnlyView = value;
     61          OnReadOnlyViewChanged();
     62          OnPropertyChanged("ReadOnlyView");
     63        }
     64      }
     65    }
     66
     67    public ItemList()
     68      : base() {
     69      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     70    }
     71    public ItemList(int capacity)
     72      : base(capacity) {
     73      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     74    }
     75    public ItemList(IEnumerable<T> collection)
     76      : base(collection) {
     77      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     78    }
     79    [StorableConstructor]
     80    protected ItemList(bool deserializing) { }
    5181
    5282    public object Clone() {
    5383      return Clone(new Cloner());
    5484    }
    55 
    5685    public virtual IDeepCloneable Clone(Cloner cloner) {
    5786      ItemList<T> clone = (ItemList<T>)Activator.CreateInstance(this.GetType());
    5887      cloner.RegisterClonedObject(this, clone);
    59       clone.ReadOnlyView = ReadOnlyView;
     88      clone.readOnlyView = readOnlyView;
    6089      clone.list = new List<T>(this.Select(x => (T)cloner.Clone(x)));
    6190      return clone;
     91    }
     92
     93    public new ReadOnlyItemList<T> AsReadOnly() {
     94      return new ReadOnlyItemList<T>(this);
    6295    }
    6396
    … …  
    76109      if (handler != null) handler(this, EventArgs.Empty);
    77110    }
     111    public event EventHandler ReadOnlyViewChanged;
     112    protected virtual void OnReadOnlyViewChanged() {
     113      EventHandler handler = ReadOnlyViewChanged;
     114      if (handler != null) handler(this, EventArgs.Empty);
     115    }
    78116  }
    79117}

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

    r3381 r3390  
    3535  [StorableClass]
    3636  [Item("ItemSet<T>", "Represents a set of items.")]
    37   public class ItemSet<T> : ObservableSet<T>, IItem where T : class, IItem {
     37  public class ItemSet<T> : ObservableSet<T>, IItemSet<T> where T : class, IItem {
    3838    public virtual string ItemName {
    3939      get { return ItemAttribute.GetName(this.GetType()); }
    … …  
    4646    }
    4747
    48     public ItemSet() : base() { }
    49     public ItemSet(IEnumerable<T> collection) : base(collection) { }
     48    [Storable]
     49    private HashSet<T> Items {
     50      get { return set; }
     51      set { set = value; }
     52    }
     53
     54    [Storable]
     55    private bool readOnlyView;
     56    public virtual bool ReadOnlyView {
     57      get { return readOnlyView; }
     58      set {
     59        if ((readOnlyView != value) && !((ICollection<T>)set).IsReadOnly) {
     60          readOnlyView = value;
     61          OnReadOnlyViewChanged();
     62          OnPropertyChanged("ReadOnlyView");
     63        }
     64      }
     65    }
     66
     67    public ItemSet()
     68      : base() {
     69      readOnlyView = ((ICollection<T>)set).IsReadOnly;
     70    }
     71    public ItemSet(IEnumerable<T> collection)
     72      : base(collection) {
     73      readOnlyView = ((ICollection<T>)set).IsReadOnly;
     74    }
     75    [StorableConstructor]
     76    protected ItemSet(bool deserializing) { }
    5077
    5178    public object Clone() {
    5279      return Clone(new Cloner());
    5380    }
    54 
    5581    public virtual IDeepCloneable Clone(Cloner cloner) {
    5682      ItemSet<T> clone = (ItemSet<T>)Activator.CreateInstance(this.GetType());
    5783      cloner.RegisterClonedObject(this, clone);
    58       clone.ReadOnlyView = ReadOnlyView;
     84      clone.readOnlyView = readOnlyView;
    5985      clone.set = new HashSet<T>(this.Select(x => (T)cloner.Clone(x)));
    6086      return clone;
     87    }
     88
     89    public new ReadOnlyItemSet<T> AsReadOnly() {
     90      return new ReadOnlyItemSet<T>(this);
    6191    }
    6292
    … …  
    75105      if (handler != null) handler(this, EventArgs.Empty);
    76106    }
     107    public event EventHandler ReadOnlyViewChanged;
     108    protected virtual void OnReadOnlyViewChanged() {
     109      EventHandler handler = ReadOnlyViewChanged;
     110      if (handler != null) handler(this, EventArgs.Empty);
     111    }
    77112  }
    78113}

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

    r3381 r3390  
    3131  [Item("NamedItemCollection<T>", "Represents a collection of named items.")]
    3232  [StorableClass]
    33   public class NamedItemCollection<T> : ObservableKeyedCollection<string, T>, IItem where T : class, INamedItem {
    34     public virtual string ItemName {
    35       get { return ItemAttribute.GetName(this.GetType()); }
    36     }
    37     public virtual string ItemDescription {
    38       get { return ItemAttribute.GetDescription(this.GetType()); }
    39     }
    40     public virtual Image ItemImage {
    41       get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Class; }
    42     }
    43 
     33  public class NamedItemCollection<T> : KeyedItemCollection<string, T> where T : class, INamedItem {
    4434    public NamedItemCollection() : base() { }
    4535    public NamedItemCollection(int capacity) : base(capacity) { }
    … …  
    4737      Initialize();
    4838    }
     39    [StorableConstructor]
     40    protected NamedItemCollection(bool deserializing) { }
    4941
    5042    [StorableHook(HookType.AfterDeserialization)]
    … …  
    5345    }
    5446
    55     public object Clone() {
    56       return Clone(new Cloner());
    57     }
    58     public virtual IDeepCloneable Clone(Cloner cloner) {
    59       NamedItemCollection<T> clone = (NamedItemCollection<T>)Activator.CreateInstance(this.GetType());
    60       cloner.RegisterClonedObject(this, clone);
    61       clone.ReadOnlyView = ReadOnlyView;
    62       foreach (string key in dict.Keys)
    63         clone.dict.Add(key, (T)cloner.Clone(dict[key]));
     47    public override IDeepCloneable Clone(Cloner cloner) {
     48      NamedItemCollection<T> clone = (NamedItemCollection<T>)base.Clone(cloner);
    6449      clone.Initialize();
    6550      return clone;
    66     }
    67 
    68     public override string ToString() {
    69       return ItemName;
    70     }
    71 
    72     public event EventHandler ItemImageChanged;
    73     protected virtual void OnItemImageChanged() {
    74       EventHandler handler = ItemImageChanged;
    75       if (handler != null) handler(this, EventArgs.Empty);
    76     }
    77     public event EventHandler ToStringChanged;
    78     protected virtual void OnToStringChanged() {
    79       EventHandler handler = ToStringChanged;
    80       if (handler != null) handler(this, EventArgs.Empty);
    8151    }
    8252

  • trunk/sources/HeuristicLab.Core/3.3/Collections/OperationCollection.cs

    r3385 r3390  
    5151      parallel = false;
    5252    }
     53    [StorableConstructor]
     54    private OperationCollection(bool deserializing) { }
    5355
    5456    public override IDeepCloneable Clone(Cloner cloner) {

  • trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorCollection.cs

    r3381 r3390  
    3535    public OperatorCollection() : base() { }
    3636    public OperatorCollection(IEnumerable<IOperator> collection) : base(collection) { }
     37    [StorableConstructor]
     38    protected OperatorCollection(bool deserializing) : base(deserializing) { }
    3739  }
    3840}

  • trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorList.cs

    r3381 r3390  
    3535    public OperatorList(int capacity) : base(capacity) { }
    3636    public OperatorList(IEnumerable<IOperator> collection) : base(collection) { }
     37    [StorableConstructor]
     38    protected OperatorList(bool deserializing) : base(deserializing) { }
    3739  }
    3840}

  • trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorSet.cs

    r3381 r3390  
    3434    public OperatorSet() : base() { }
    3535    public OperatorSet(IEnumerable<IOperator> collection) : base(collection) { }
     36    [StorableConstructor]
     37    protected OperatorSet(bool deserializing) : base(deserializing) { }
    3638  }
    3739}

  • trunk/sources/HeuristicLab.Core/3.3/Collections/ParameterCollection.cs

    r3381 r3390  
    3030    public ParameterCollection(int capacity) : base(capacity) { }
    3131    public ParameterCollection(IEnumerable<IParameter> collection) : base(collection) { }
     32    [StorableConstructor]
     33    protected ParameterCollection(bool deserializing) : base(deserializing) { }
    3234  }
    3335}

  • trunk/sources/HeuristicLab.Core/3.3/Collections/ScopeList.cs

    r3381 r3390  
    3232    public ScopeList(int capacity) : base(capacity) { }
    3333    public ScopeList(IEnumerable<IScope> collection) : base(collection) { }
     34    [StorableConstructor]
     35    private ScopeList(bool deserializing) : base(deserializing) { }
    3436
    3537    public override IDeepCloneable Clone(Cloner cloner) {

  • trunk/sources/HeuristicLab.Core/3.3/Collections/ValueParameterCollection.cs

    r3381 r3390  
    3030    public ValueParameterCollection(int capacity) : base(capacity) { }
    3131    public ValueParameterCollection(IEnumerable<IValueParameter> collection) : base(collection) { }
     32    [StorableConstructor]
     33    protected ValueParameterCollection(bool deserializing) : base(deserializing) { }
    3234  }
    3335}

  • trunk/sources/HeuristicLab.Core/3.3/Collections/VariableCollection.cs

    r3381 r3390  
    3232    public VariableCollection(int capacity) : base(capacity) { }
    3333    public VariableCollection(IEnumerable<IVariable> collection) : base(collection) { }
     34    [StorableConstructor]
     35    private VariableCollection(bool deserializing) : base(deserializing) { }
    3436
    3537    public override IDeepCloneable Clone(Cloner cloner) {

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

    r3384 r3390  
    102102    <Compile Include="Attributes\CreatableAttribute.cs" />
    103103    <None Include="HeuristicLabCorePlugin.cs.frame" />
     104    <Compile Include="Collections\ReadOnlyItemDictionary.cs" />
     105    <Compile Include="Collections\ItemDictionary.cs" />
     106    <Compile Include="Collections\ReadOnlyKeyedItemCollection.cs" />
     107    <Compile Include="Collections\KeyedItemCollection.cs" />
     108    <Compile Include="Collections\ReadOnlyItemSet.cs" />
     109    <Compile Include="Collections\ReadOnlyItemList.cs" />
     110    <Compile Include="Collections\ReadOnlyItemArray.cs" />
     111    <Compile Include="Collections\ReadOnlyItemCollection.cs" />
     112    <Compile Include="Collections\ItemArray.cs" />
     113    <Compile Include="Collections\ItemCollection.cs" />
     114    <Compile Include="Collections\ItemList.cs" />
     115    <Compile Include="Collections\ItemSet.cs" />
     116    <Compile Include="Collections\NamedItemCollection.cs" />
     117    <Compile Include="Collections\OperationCollection.cs" />
     118    <Compile Include="Collections\OperatorCollection.cs" />
     119    <Compile Include="Collections\OperatorList.cs" />
     120    <Compile Include="Collections\OperatorSet.cs" />
     121    <Compile Include="Collections\ParameterCollection.cs" />
     122    <Compile Include="Collections\ScopeList.cs" />
     123    <Compile Include="Collections\ValueParameterCollection.cs" />
     124    <Compile Include="Collections\VariableCollection.cs" />
     125    <Compile Include="Interfaces\IKeyedItemCollection.cs" />
     126    <Compile Include="Interfaces\IItemList.cs" />
     127    <Compile Include="Interfaces\IItemSet.cs" />
     128    <Compile Include="Interfaces\IItemDictionary.cs" />
     129    <Compile Include="Interfaces\IItemArray.cs" />
     130    <Compile Include="Interfaces\IItemCollection.cs" />
    104131    <Compile Include="Log.cs" />
    105132    <Compile Include="Executable.cs" />
    … …  
    112139    <Compile Include="Interfaces\IExecutionContext.cs" />
    113140    <Compile Include="Interfaces\IOperation.cs" />
    114     <Compile Include="OperationCollection.cs" />
    115141    <Compile Include="ParameterizedNamedItem.cs" />
    116     <Compile Include="ValueParameterCollection.cs" />
    117142    <Compile Include="Interfaces\IValueLookupParameter.cs" />
    118143    <Compile Include="Interfaces\IValueParameter.cs" />
    119144    <Compile Include="Interfaces\ILookupParameter.cs" />
    120     <Compile Include="ItemArray.cs" />
    121145    <Compile Include="Engine.cs" />
    122146    <Compile Include="Interfaces\IScope.cs" />
    … …  
    126150    <Compile Include="OperatorGraph.cs" />
    127151    <Compile Include="Interfaces\IParameter.cs" />
    128     <Compile Include="OperatorCollection.cs" />
    129     <Compile Include="ItemCollection.cs" />
    130     <Compile Include="OperatorSet.cs" />
    131     <Compile Include="ItemSet.cs" />
    132     <Compile Include="ItemList.cs" />
    133152    <Compile Include="Interfaces\IEngine.cs">
    134153      <SubType>Code</SubType>
    135154    </Compile>
    136155    <Compile Include="ExecutionContext.cs" />
    137     <Compile Include="OperatorList.cs" />
    138     <Compile Include="ParameterCollection.cs" />
    139     <Compile Include="VariableCollection.cs" />
    140     <Compile Include="ScopeList.cs" />
    141     <Compile Include="NamedItemCollection.cs" />
    142156    <Compile Include="Interfaces\INamedItem.cs" />
    143157    <Compile Include="Interfaces\IItem.cs" />
Note: See TracChangeset for help on using the changeset viewer.