Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
11/06/10 01:56:04 (13 years ago)
Author:
swagner
Message:

Merged cloning refactoring branch back into trunk (#922)

Location:
trunk/sources
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources

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

    r4068 r4722  
    4646
    4747    /// <summary>
     48    /// Instantiates an empty CheckedItemCollection for deserialization.
     49    /// </summary>
     50    /// <param name="deserializing"></param>
     51    [StorableConstructor]
     52    protected CheckedItemCollection(bool deserializing) : base(deserializing) { }
     53    protected CheckedItemCollection(CheckedItemCollection<T> original, Cloner cloner)
     54      : base(original, cloner) {
     55      list = new List<T>(original.Select(x => cloner.Clone(x)));
     56      checkedState = new Dictionary<T, bool>();
     57      foreach (var pair in original.checkedState)
     58        checkedState.Add(cloner.Clone(pair.Key), pair.Value);
     59    }
     60    /// <summary>
    4861    /// Instantiates a new CheckedItemCollection.
    4962    /// </summary>
    … …  
    7184          checkedState.Add(item, true);
    7285    }
    73     /// <summary>
    74     /// Instantiates an empty CheckedItemCollection for deserialization.
    75     /// </summary>
    76     /// <param name="deserializing"></param>
    77     [StorableConstructor]
    78     protected CheckedItemCollection(bool deserializing) : base(deserializing) { }
    7986
    8087    /// <summary>
    … …  
    179186    /// <returns>A clone of the CheckedItemCollection</returns>
    180187    public override IDeepCloneable Clone(Cloner cloner) {
    181       CheckedItemCollection<T> clone = (CheckedItemCollection<T>)Activator.CreateInstance(this.GetType());
    182       cloner.RegisterClonedObject(this, clone);
    183       clone.list = new List<T>(this.Select(x => (T)cloner.Clone(x)));
    184       clone.checkedState = new Dictionary<T, bool>();
    185       foreach (var pair in checkedState)
    186         clone.checkedState.Add((T)cloner.Clone(pair.Key), pair.Value);
    187       return clone;
     188      return new CheckedItemCollection<T>(this, cloner);
    188189    }
    189190  }

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

    r4068 r4722  
    4848      }
    4949    }
     50
     51    /// <summary>
     52    /// Instantiates a new CheckedItemList for deserialization.
     53    /// </summary>
     54    /// <param name="deserializing"></param>
     55    [StorableConstructor]
     56    protected CheckedItemList(bool deserializing) : base(deserializing) { }
     57    protected CheckedItemList(CheckedItemList<T> original, Cloner cloner)
     58      : base(original, cloner) {
     59      list = new List<T>(original.Select(x => (T)cloner.Clone(x)));
     60      checkedState = new Dictionary<T, bool>();
     61      foreach (var pair in original.checkedState)
     62        checkedState.Add(cloner.Clone(pair.Key), pair.Value);
     63    }
    5064    /// <summary>
    5165    /// Instantiates an empty CheckedItemList.
    … …  
    7589      }
    7690    }
    77     /// <summary>
    78     /// Instantiates a new CheckedItemList for deserialization.
    79     /// </summary>
    80     /// <param name="deserializing"></param>
    81     [StorableConstructor]
    82     protected CheckedItemList(bool deserializing) : base(deserializing) { }
    8391
    8492    /// <summary>
    … …  
    228236    /// <returns>A deep clone of the CheckedItemList</returns>
    229237    public override IDeepCloneable Clone(Cloner cloner) {
    230       CheckedItemList<T> clone = (CheckedItemList<T>)Activator.CreateInstance(this.GetType());
    231       cloner.RegisterClonedObject(this, clone);
    232       clone.list = new List<T>(this.Select(x => (T)cloner.Clone(x)));
    233       clone.checkedState = new Dictionary<T, bool>();
    234       foreach (var pair in checkedState)
    235         clone.checkedState.Add((T)cloner.Clone(pair.Key), pair.Value);
    236       return clone;
     238      return new CheckedItemList<T>(this, cloner);
    237239    }
    238240  }

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

    r4068 r4722  
    2121
    2222using System.Collections.Generic;
     23using HeuristicLab.Common;
    2324using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2425
    … …  
    2728  [Item("ConstraintCollection", "Represents a collection of constraints.")]
    2829  public class ConstraintCollection : ItemCollection<IConstraint> {
     30    [StorableConstructor]
     31    protected ConstraintCollection(bool deserializing) : base(deserializing) { }
     32    protected ConstraintCollection(ConstraintCollection original, Cloner cloner) : base(original, cloner) { }
    2933    public ConstraintCollection() : base() { }
    3034    public ConstraintCollection(int capacity) : base(capacity) { }
    3135    public ConstraintCollection(IEnumerable<IConstraint> collection) : base(collection) { }
    32     [StorableConstructor]
    33     protected ConstraintCollection(bool deserializing) : base(deserializing) { }
     36
     37    public override IDeepCloneable Clone(Cloner cloner) { return new ConstraintCollection(this, cloner); }
    3438  }
    3539}

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

    r4419 r4722  
    4646    }
    4747
     48    [StorableConstructor]
     49    protected ItemArray(bool deserializing) : base(deserializing) { }
     50    protected ItemArray(ItemArray<T> original, Cloner cloner) {
     51      cloner.RegisterClonedObject(original, this);
     52      array = original.Select(x => cloner.Clone(x)).ToArray();
     53    }
    4854    public ItemArray() : base() { }
    4955    public ItemArray(int length) : base(length) { }
    5056    public ItemArray(T[] array) : base(array) { }
    5157    public ItemArray(IEnumerable<T> collection) : base(collection) { }
    52     [StorableConstructor]
    53     protected ItemArray(bool deserializing) : base(deserializing) { }
    5458
    5559    public object Clone() {
    … …  
    5761    }
    5862    public virtual IDeepCloneable Clone(Cloner cloner) {
    59       ItemArray<T> clone = (ItemArray<T>)Activator.CreateInstance(this.GetType());
    60       cloner.RegisterClonedObject(this, clone);
    61       clone.array = this.Select(x => (T)cloner.Clone(x)).ToArray();
    62       return clone;
     63      return new ItemArray<T>(this, cloner);
    6364    }
    6465

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

    r4419 r4722  
    4646    }
    4747
     48    [StorableConstructor]
     49    protected ItemCollection(bool deserializing) : base(deserializing) { }
     50    protected ItemCollection(ItemCollection<T> original, Cloner cloner) {
     51      cloner.RegisterClonedObject(original, this);
     52      list = new List<T>(original.Select(x => cloner.Clone(x)));
     53    }
    4854    public ItemCollection() : base() { }
    4955    public ItemCollection(int capacity) : base(capacity) { }
    5056    public ItemCollection(IEnumerable<T> collection) : base(collection) { }
    51     [StorableConstructor]
    52     protected ItemCollection(bool deserializing) : base(deserializing) { }
    5357
    5458    public object Clone() {
    … …  
    5660    }
    5761    public virtual IDeepCloneable Clone(Cloner cloner) {
    58       ItemCollection<T> clone = (ItemCollection<T>)Activator.CreateInstance(this.GetType());
    59       cloner.RegisterClonedObject(this, clone);
    60       clone.list = new List<T>(this.Select(x => (T)cloner.Clone(x)));
    61       return clone;
     62      return new ItemCollection<T>(this, cloner);
    6263    }
    6364

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

    r4419 r4722  
    4848    }
    4949
     50    [StorableConstructor]
     51    protected ItemDictionary(bool deserializing) : base(deserializing) { }
     52    protected ItemDictionary(ItemDictionary<TKey, TValue> original, Cloner cloner) {
     53      cloner.RegisterClonedObject(original, this);
     54      foreach (TKey key in dict.Keys)
     55        dict.Add(cloner.Clone(key), cloner.Clone(dict[key]));
     56    }
    5057    public ItemDictionary() : base() { }
    5158    public ItemDictionary(int capacity) : base(capacity) { }
    5259    public ItemDictionary(IDictionary<TKey, TValue> dictionary) : base(dictionary) { }
    53     [StorableConstructor]
    54     protected ItemDictionary(bool deserializing) : base(deserializing) { }
    5560
    5661    public object Clone() {
    … …  
    5863    }
    5964    public virtual IDeepCloneable Clone(Cloner cloner) {
    60       ItemDictionary<TKey, TValue> clone = (ItemDictionary<TKey, TValue>)Activator.CreateInstance(this.GetType());
    61       cloner.RegisterClonedObject(this, clone);
    62       foreach (TKey key in dict.Keys)
    63         clone.dict.Add((TKey)cloner.Clone(key), (TValue)cloner.Clone(dict[key]));
    64       return clone;
     65      return new ItemDictionary<TKey, TValue>(this, cloner);
    6566    }
    6667

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

    r4419 r4722  
    4646    }
    4747
     48    [StorableConstructor]
     49    protected ItemList(bool deserializing) : base(deserializing) { }
     50    protected ItemList(ItemList<T> original, Cloner cloner) {
     51      cloner.RegisterClonedObject(original, this);
     52      list = new List<T>(original.Select(x => cloner.Clone(x)));
     53    }
    4854    public ItemList() : base() { }
    4955    public ItemList(int capacity) : base(capacity) { }
    5056    public ItemList(IEnumerable<T> collection) : base(collection) { }
    51     [StorableConstructor]
    52     protected ItemList(bool deserializing) : base(deserializing) { }
    5357
    5458    public object Clone() {
    … …  
    5660    }
    5761    public virtual IDeepCloneable Clone(Cloner cloner) {
    58       ItemList<T> clone = (ItemList<T>)Activator.CreateInstance(this.GetType());
    59       cloner.RegisterClonedObject(this, clone);
    60       clone.list = new List<T>(this.Select(x => (T)cloner.Clone(x)));
    61       return clone;
     62      return new ItemList<T>(this, cloner);
    6263    }
    6364

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

    r4419 r4722  
    4646    }
    4747
     48    [StorableConstructor]
     49    protected ItemSet(bool deserializing) : base(deserializing) { }
     50    protected ItemSet(ItemSet<T> original, Cloner cloner) {
     51      cloner.RegisterClonedObject(original, this);
     52      set = new HashSet<T>(original.Select(x => cloner.Clone(x)));
     53    }
    4854    public ItemSet() : base() { }
    4955    public ItemSet(IEnumerable<T> collection) : base(collection) { }
    50     [StorableConstructor]
    51     protected ItemSet(bool deserializing) : base(deserializing) { }
    5256
    5357    public object Clone() {
    … …  
    5559    }
    5660    public virtual IDeepCloneable Clone(Cloner cloner) {
    57       ItemSet<T> clone = (ItemSet<T>)Activator.CreateInstance(this.GetType());
    58       cloner.RegisterClonedObject(this, clone);
    59       clone.set = new HashSet<T>(this.Select(x => (T)cloner.Clone(x)));
    60       return clone;
     61      return new ItemSet<T>(this, cloner);
    6162    }
    6263

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

    r4419 r4722  
    4444    }
    4545
     46    [StorableConstructor]
     47    protected KeyedItemCollection(bool deserializing) : base(deserializing) { }
     48    protected KeyedItemCollection(KeyedItemCollection<TKey, TItem> original, Cloner cloner) {
     49      cloner.RegisterClonedObject(original, this);
     50      foreach (TItem item in original.dict.Values) {
     51        TItem clonedItem = cloner.Clone(item);
     52        dict.Add(GetKeyForItem(clonedItem), clonedItem);
     53      }
     54    }
    4655    protected KeyedItemCollection() : base() { }
    4756    protected KeyedItemCollection(int capacity) : base(capacity) { }
    4857    protected KeyedItemCollection(IEnumerable<TItem> collection) : base(collection) { }
    49     [StorableConstructor]
    50     protected KeyedItemCollection(bool deserializing) : base(deserializing) { }
    5158
    5259    public object Clone() {
    5360      return Clone(new Cloner());
    5461    }
    55     public virtual IDeepCloneable Clone(Cloner cloner) {
    56       KeyedItemCollection<TKey, TItem> clone = (KeyedItemCollection<TKey, TItem>)Activator.CreateInstance(this.GetType());
    57       cloner.RegisterClonedObject(this, clone);
    58       foreach (TItem item in dict.Values) {
    59         TItem clonedItem = (TItem)cloner.Clone(item);
    60         clone.dict.Add(GetKeyForItem(clonedItem), clonedItem);
    61       }
    62       return clone;
    63     }
     62    public abstract IDeepCloneable Clone(Cloner cloner);
    6463
    6564    public new ReadOnlyKeyedItemCollection<TKey, TItem> AsReadOnly() {

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

    r4068 r4722  
    2929  [StorableClass]
    3030  public class NamedItemCollection<T> : KeyedItemCollection<string, T> where T : class, INamedItem {
     31    [StorableConstructor]
     32    protected NamedItemCollection(bool deserializing) : base(deserializing) { }
     33    protected NamedItemCollection(NamedItemCollection<T> original, Cloner cloner)
     34      : base(original, cloner) {
     35      RegisterItemEvents(this);
     36    }
    3137    public NamedItemCollection() : base() { }
    3238    public NamedItemCollection(int capacity) : base(capacity) { }
    3339    public NamedItemCollection(IEnumerable<T> collection)
    3440      : base(collection) {
    35       Initialize();
     41      RegisterItemEvents(this);
    3642    }
    37     [StorableConstructor]
    38     protected NamedItemCollection(bool deserializing) : base(deserializing) { }
    3943
    4044    [StorableHook(HookType.AfterDeserialization)]
    41     protected void Initialize() {
     45    private void AfterDeserialization() {
    4246      RegisterItemEvents(this);
    4347    }
    4448
    4549    public override IDeepCloneable Clone(Cloner cloner) {
    46       NamedItemCollection<T> clone = (NamedItemCollection<T>)base.Clone(cloner);
    47       clone.Initialize();
    48       return clone;
     50      return new NamedItemCollection<T>(this, cloner);
    4951    }
    5052
    … …  
    7375    }
    7476
    75     private void RegisterItemEvents(IEnumerable<T> items) {
     77    protected void RegisterItemEvents(IEnumerable<T> items) {
    7678      foreach (T item in items) {
    7779        if (item != null) {

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

    r3390 r4722  
    2020#endregion
    2121
    22 using System;
    2322using System.Collections.Generic;
    2423using System.Linq;
    … …  
    3938    }
    4039
     40    [StorableConstructor]
     41    private OperationCollection(bool deserializing) { }
     42    private OperationCollection(OperationCollection original, Cloner cloner)
     43      : base(original, cloner) {
     44      operations = new List<IOperation>(original.Select(x => cloner.Clone(x)));
     45      parallel = original.parallel;
     46    }
    4147    public OperationCollection() {
    4248      operations = new List<IOperation>();
    … …  
    5157      parallel = false;
    5258    }
    53     [StorableConstructor]
    54     private OperationCollection(bool deserializing) { }
    5559
    5660    public override IDeepCloneable Clone(Cloner cloner) {
    57       OperationCollection clone = (OperationCollection)Activator.CreateInstance(this.GetType());
    58       cloner.RegisterClonedObject(this, clone);
    59       clone.operations = new List<IOperation>(this.Select(x => (IOperation)cloner.Clone(x)));
    60       clone.parallel = parallel;
    61       return clone;
     61      return new OperationCollection(this, cloner);
    6262    }
    6363

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

    r4419 r4722  
    2121
    2222using System.Collections.Generic;
     23using HeuristicLab.Common;
    2324using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2425
    … …  
    2728  [Item("Operator Collection", "Represents a collection of operators.")]
    2829  public class OperatorCollection : ItemCollection<IOperator> {
     30    [StorableConstructor]
     31    protected OperatorCollection(bool deserializing) : base(deserializing) { }
     32    protected OperatorCollection(OperatorCollection original, Cloner cloner) : base(original, cloner) { }
    2933    public OperatorCollection() : base() { }
    3034    public OperatorCollection(IEnumerable<IOperator> collection) : base(collection) { }
    31     [StorableConstructor]
    32     protected OperatorCollection(bool deserializing) : base(deserializing) { }
     35
     36    public override IDeepCloneable Clone(Cloner cloner) { return new OperatorCollection(this, cloner); }
    3337  }
    3438}

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

    r4068 r4722  
    2121
    2222using System.Collections.Generic;
     23using HeuristicLab.Common;
    2324using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2425
    … …  
    2728  [Item("OperatorList", "Represents a list of operators.")]
    2829  public class OperatorList : ItemList<IOperator> {
     30    [StorableConstructor]
     31    protected OperatorList(bool deserializing) : base(deserializing) { }
     32    protected OperatorList(OperatorList original, Cloner cloner) : base(original, cloner) { }
    2933    public OperatorList() : base() { }
    3034    public OperatorList(int capacity) : base(capacity) { }
    3135    public OperatorList(IEnumerable<IOperator> collection) : base(collection) { }
    32     [StorableConstructor]
    33     protected OperatorList(bool deserializing) : base(deserializing) { }
     36
     37    public override IDeepCloneable Clone(Cloner cloner) { return new OperatorList(this, cloner); }
    3438  }
    3539}

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

    r4068 r4722  
    2121
    2222using System.Collections.Generic;
     23using HeuristicLab.Common;
    2324using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2425
    … …  
    2728  [Item("OperatorSet", "Represents a set of operators.")]
    2829  public class OperatorSet : ItemSet<IOperator> {
     30    [StorableConstructor]
     31    protected OperatorSet(bool deserializing) : base(deserializing) { }
     32    protected OperatorSet(OperatorSet original, Cloner cloner) : base(original, cloner) { }
    2933    public OperatorSet() : base() { }
    3034    public OperatorSet(IEnumerable<IOperator> collection) : base(collection) { }
    31     [StorableConstructor]
    32     protected OperatorSet(bool deserializing) : base(deserializing) { }
     35
     36    public override IDeepCloneable Clone(Cloner cloner) { return new OperatorSet(this, cloner); }
    3337  }
    3438}

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

    r3390 r4722  
    2121
    2222using System.Collections.Generic;
     23using HeuristicLab.Common;
    2324using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2425
    … …  
    2728  [Item("ParameterCollection", "Represents a collection of parameters.")]
    2829  public class ParameterCollection : NamedItemCollection<IParameter> {
     30    [StorableConstructor]
     31    protected ParameterCollection(bool deserializing) : base(deserializing) { }
     32    protected ParameterCollection(ParameterCollection original, Cloner cloner) : base(original, cloner) { }
    2933    public ParameterCollection() : base() { }
    3034    public ParameterCollection(int capacity) : base(capacity) { }
    3135    public ParameterCollection(IEnumerable<IParameter> collection) : base(collection) { }
    32     [StorableConstructor]
    33     protected ParameterCollection(bool deserializing) : base(deserializing) { }
     36
     37    public override IDeepCloneable Clone(Cloner cloner) { return new ParameterCollection(this, cloner); }
    3438  }
    3539}

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

    r4290 r4722  
    3434    }
    3535
     36    [StorableConstructor]
     37    protected ReadOnlyCheckedItemCollection(bool deserializing) : base(deserializing) { }
     38    protected ReadOnlyCheckedItemCollection(ReadOnlyCheckedItemCollection<T> original, Cloner cloner)
     39      : base(original, cloner) {
     40      CheckedItemCollection.CheckedItemsChanged += new CollectionItemsChangedEventHandler<T>(collection_CheckedItemsChanged);
     41    }
    3642    public ReadOnlyCheckedItemCollection() : base(new CheckedItemCollection<T>()) { }
    3743    public ReadOnlyCheckedItemCollection(ICheckedItemCollection<T> collection)
    … …  
    4046    }
    4147
    42     [StorableConstructor]
    43     protected ReadOnlyCheckedItemCollection(bool deserializing) : base(deserializing) { }
    4448    [StorableHook(HookType.AfterDeserialization)]
    45     private void AfterDeserializationHook() {
     49    private void AfterDeserialization() {
    4650      CheckedItemCollection.CheckedItemsChanged += new CollectionItemsChangedEventHandler<T>(collection_CheckedItemsChanged);
    4751    }
    4852
    49     public override IDeepCloneable Clone(Common.Cloner cloner) {
    50       ReadOnlyCheckedItemCollection<T> clone = (ReadOnlyCheckedItemCollection<T>)base.Clone(cloner);
    51       clone.CheckedItemCollection.CheckedItemsChanged += new CollectionItemsChangedEventHandler<T>(clone.collection_CheckedItemsChanged);
    52       return clone;
     53    public override IDeepCloneable Clone(Cloner cloner) {
     54      return new ReadOnlyCheckedItemCollection<T>(this, cloner);
    5355    }
    5456

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

    r4290 r4722  
    2323using System.Collections.Generic;
    2424using HeuristicLab.Collections;
     25using HeuristicLab.Common;
    2526using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2627
    … …  
    3334    }
    3435
     36    [StorableConstructor]
     37    protected ReadOnlyCheckedItemList(bool deserializing) : base(deserializing) { }
     38    protected ReadOnlyCheckedItemList(ReadOnlyCheckedItemList<T> original, Cloner cloner)
     39      : base(original, cloner) {
     40      CheckedItemList.CheckedItemsChanged += new CollectionItemsChangedEventHandler<IndexedItem<T>>(list_CheckedItemsChanged);
     41    }
    3542    public ReadOnlyCheckedItemList() : base(new CheckedItemList<T>()) { }
    3643    public ReadOnlyCheckedItemList(ICheckedItemList<T> list)
    … …  
    3946    }
    4047
    41     [StorableConstructor]
    42     protected ReadOnlyCheckedItemList(bool deserializing) : base(deserializing) { }
    4348    [StorableHook(HookType.AfterDeserialization)]
    44     private void AfterDeserializationHook() {
     49    private void AfterDeserialization() {
    4550      CheckedItemList.CheckedItemsChanged += new CollectionItemsChangedEventHandler<IndexedItem<T>>(list_CheckedItemsChanged);
    4651    }
    4752
    48     public override Common.IDeepCloneable Clone(Common.Cloner cloner) {
    49       ReadOnlyCheckedItemList<T> clone = (ReadOnlyCheckedItemList<T>)base.Clone(cloner);
    50       clone.CheckedItemList.CheckedItemsChanged += new CollectionItemsChangedEventHandler<IndexedItem<T>>(clone.list_CheckedItemsChanged);
    51       return clone;
     53    public override IDeepCloneable Clone(Cloner cloner) {
     54      return new ReadOnlyCheckedItemList<T>(this, cloner);
    5255    }
    5356

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

    r4419 r4722  
    4444    }
    4545
     46    [StorableConstructor]
     47    protected ReadOnlyItemArray(bool deserializing) : base(deserializing) { }
     48    protected ReadOnlyItemArray(ReadOnlyItemArray<T> original, Cloner cloner) {
     49      cloner.RegisterClonedObject(original, this);
     50      array = cloner.Clone((IItemArray<T>)original.array);
     51      RegisterEvents();
     52    }
    4653    public ReadOnlyItemArray() : base(new ItemArray<T>()) { }
    4754    public ReadOnlyItemArray(IItemArray<T> array) : base(array) { }
    48     [StorableConstructor]
    49     protected ReadOnlyItemArray(bool deserializing) : base(deserializing) { }
    5055
    5156    public object Clone() {
    … …  
    5358    }
    5459    public virtual IDeepCloneable Clone(Cloner cloner) {
    55       ReadOnlyItemArray<T> clone = (ReadOnlyItemArray<T>)Activator.CreateInstance(this.GetType());
    56       cloner.RegisterClonedObject(this, clone);
    57       clone.array = (IItemArray<T>)((IItemArray<T>)array).Clone(cloner);
    58       clone.RegisterEvents();
    59       return clone;
     60      return new ReadOnlyItemArray<T>(this, cloner);
    6061    }
    6162

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

    r4419 r4722  
    4444    }
    4545
     46    [StorableConstructor]
     47    protected ReadOnlyItemCollection(bool deserializing) : base(deserializing) { }
     48    protected ReadOnlyItemCollection(ReadOnlyItemCollection<T> original, Cloner cloner) {
     49      cloner.RegisterClonedObject(original, this);
     50      collection = cloner.Clone((IItemCollection<T>)original.collection);
     51      RegisterEvents();
     52    }
    4653    public ReadOnlyItemCollection() : base(new ItemCollection<T>()) { }
    4754    public ReadOnlyItemCollection(IItemCollection<T> collection) : base(collection) { }
    48     [StorableConstructor]
    49     protected ReadOnlyItemCollection(bool deserializing) : base(deserializing) { }
    5055
    5156    public object Clone() {
    … …  
    5358    }
    5459    public virtual IDeepCloneable Clone(Cloner cloner) {
    55       ReadOnlyItemCollection<T> clone = (ReadOnlyItemCollection<T>)Activator.CreateInstance(this.GetType());
    56       cloner.RegisterClonedObject(this, clone);
    57       clone.collection = (IItemCollection<T>)((IItemCollection<T>)collection).Clone(cloner);
    58       clone.RegisterEvents();
    59       return clone;
     60      return new ReadOnlyItemCollection<T>(this, cloner);
    6061    }
    6162

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

    r4419 r4722  
    4747    }
    4848
     49    [StorableConstructor]
     50    protected ReadOnlyItemDictionary(bool deserializing) : base(deserializing) { }
     51    protected ReadOnlyItemDictionary(ReadOnlyItemDictionary<TKey, TValue> original, Cloner cloner) {
     52      cloner.RegisterClonedObject(original, this);
     53      dict = cloner.Clone((IItemDictionary<TKey, TValue>)original.dict);
     54      RegisterEvents();
     55    }
    4956    public ReadOnlyItemDictionary() : base(new ItemDictionary<TKey, TValue>()) { }
    5057    public ReadOnlyItemDictionary(IItemDictionary<TKey, TValue> dictionary) : base(dictionary) { }
    51     [StorableConstructor]
    52     protected ReadOnlyItemDictionary(bool deserializing) : base(deserializing) { }
    5358
    5459    public object Clone() {
    … …  
    5661    }
    5762    public virtual IDeepCloneable Clone(Cloner cloner) {
    58       ReadOnlyItemDictionary<TKey, TValue> clone = (ReadOnlyItemDictionary<TKey, TValue>)Activator.CreateInstance(this.GetType());
    59       cloner.RegisterClonedObject(this, clone);
    60       clone.dict = (IItemDictionary<TKey, TValue>)((IItemDictionary<TKey, TValue>)dict).Clone(cloner);
    61       clone.RegisterEvents();
    62       return clone;
     63      return new ReadOnlyItemDictionary<TKey, TValue>(this, cloner);
    6364    }
    6465

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

    r4419 r4722  
    4444    }
    4545
     46    [StorableConstructor]
     47    protected ReadOnlyItemList(bool deserializing) : base(deserializing) { }
     48    protected ReadOnlyItemList(ReadOnlyItemList<T> original, Cloner cloner) {
     49      cloner.RegisterClonedObject(original, this);
     50      list = cloner.Clone((IItemList<T>)original.list);
     51      RegisterEvents();
     52    }
    4653    public ReadOnlyItemList() : base(new ItemList<T>()) { }
    4754    public ReadOnlyItemList(IItemList<T> list) : base(list) { }
    48     [StorableConstructor]
    49     protected ReadOnlyItemList(bool deserializing) : base(deserializing) { }
    5055
    5156    public object Clone() {
    … …  
    5358    }
    5459    public virtual IDeepCloneable Clone(Cloner cloner) {
    55       ReadOnlyItemList<T> clone = (ReadOnlyItemList<T>)Activator.CreateInstance(this.GetType());
    56       cloner.RegisterClonedObject(this, clone);
    57       clone.list = (IItemList<T>)((IItemList<T>)list).Clone(cloner);
    58       clone.RegisterEvents();
    59       return clone;
     60      return new ReadOnlyItemList<T>(this, cloner);
    6061    }
    6162

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

    r4419 r4722  
    4444    }
    4545
     46    [StorableConstructor]
     47    protected ReadOnlyItemSet(bool deserializing) : base(deserializing) { }
     48    protected ReadOnlyItemSet(ReadOnlyItemSet<T> original, Cloner cloner) {
     49      cloner.RegisterClonedObject(original, this);
     50      set = cloner.Clone((IItemSet<T>)original.set);
     51      RegisterEvents();
     52    }
    4653    public ReadOnlyItemSet() : base(new ItemSet<T>()) { }
    4754    public ReadOnlyItemSet(IItemSet<T> set) : base(set) { }
    48     [StorableConstructor]
    49     protected ReadOnlyItemSet(bool deserializing) : base(deserializing) { }
    5055
    5156    public object Clone() {
    … …  
    5358    }
    5459    public virtual IDeepCloneable Clone(Cloner cloner) {
    55       ReadOnlyItemSet<T> clone = (ReadOnlyItemSet<T>)Activator.CreateInstance(this.GetType());
    56       cloner.RegisterClonedObject(this, clone);
    57       clone.set = (IItemSet<T>)((IItemSet<T>)set).Clone(cloner);
    58       clone.RegisterEvents();
    59       return clone;
     60      return new ReadOnlyItemSet<T>(this, cloner);
    6061    }
    6162

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

    r4419 r4722  
    4444    }
    4545
     46    [StorableConstructor]
     47    protected ReadOnlyKeyedItemCollection(bool deserializing) : base(deserializing) { }
     48    protected ReadOnlyKeyedItemCollection(ReadOnlyKeyedItemCollection<TKey, TItem> original, Cloner cloner) {
     49      cloner.RegisterClonedObject(original, this);
     50      collection = cloner.Clone((IKeyedItemCollection<TKey, TItem>)original.collection);
     51      RegisterEvents();
     52    }
    4653    protected ReadOnlyKeyedItemCollection() : base() { }
    4754    public ReadOnlyKeyedItemCollection(IKeyedItemCollection<TKey, TItem> collection) : base(collection) { }
    48     [StorableConstructor]
    49     protected ReadOnlyKeyedItemCollection(bool deserializing) : base(deserializing) { }
    5055
    5156    public object Clone() {
    … …  
    5358    }
    5459    public virtual IDeepCloneable Clone(Cloner cloner) {
    55       ReadOnlyKeyedItemCollection<TKey, TItem> clone = (ReadOnlyKeyedItemCollection<TKey, TItem>)Activator.CreateInstance(this.GetType());
    56       cloner.RegisterClonedObject(this, clone);
    57       clone.collection = (IKeyedItemCollection<TKey, TItem>)((IKeyedItemCollection<TKey, TItem>)collection).Clone(cloner);
    58       clone.RegisterEvents();
    59       return clone;
     60      return new ReadOnlyKeyedItemCollection<TKey, TItem>(this, cloner);
    6061    }
    6162

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

    r3431 r4722  
    2929  [Item("ScopeList", "Represents a list of scopes.")]
    3030  public sealed class ScopeList : ItemList<IScope> {
     31    [StorableConstructor]
     32    private ScopeList(bool deserializing) : base(deserializing) { }
     33    private ScopeList(ScopeList original, Cloner cloner)
     34      : base(original, cloner) {
     35      list = new List<IScope>(original.Select(x => cloner.Clone(x)));
     36    }
    3137    public ScopeList() : base() { }
    3238    public ScopeList(int capacity) : base(capacity) { }
    3339    public ScopeList(IEnumerable<IScope> collection) : base(collection) { }
    34     [StorableConstructor]
    35     private ScopeList(bool deserializing) : base(deserializing) { }
    3640
    3741    public override IDeepCloneable Clone(Cloner cloner) {
    38       ScopeList clone = new ScopeList();
    39       cloner.RegisterClonedObject(this, clone);
    40       clone.list = new List<IScope>(this.Select(x => (IScope)cloner.Clone(x)));
    41       return clone;
     42      return new ScopeList(this, cloner);
    4243    }
    4344  }

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

    r3390 r4722  
    2121
    2222using System.Collections.Generic;
     23using HeuristicLab.Common;
    2324using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2425
    … …  
    2728  [Item("ValueParameterCollection", "Represents a collection of value parameters.")]
    2829  public class ValueParameterCollection : NamedItemCollection<IValueParameter> {
     30    [StorableConstructor]
     31    protected ValueParameterCollection(bool deserializing) : base(deserializing) { }
     32    protected ValueParameterCollection(ValueParameterCollection original, Cloner cloner) : base(original, cloner) { }
    2933    public ValueParameterCollection() : base() { }
    3034    public ValueParameterCollection(int capacity) : base(capacity) { }
    3135    public ValueParameterCollection(IEnumerable<IValueParameter> collection) : base(collection) { }
    32     [StorableConstructor]
    33     protected ValueParameterCollection(bool deserializing) : base(deserializing) { }
     36
     37    public override IDeepCloneable Clone(Cloner cloner) { return new ValueParameterCollection(this, cloner); }
    3438  }
    3539}

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

    r4068 r4722  
    2828  [Item("VariableCollection", "Represents a collection of variables.")]
    2929  public sealed class VariableCollection : NamedItemCollection<IVariable> {
     30    [StorableConstructor]
     31    private VariableCollection(bool deserializing) : base(deserializing) { }
     32    private VariableCollection(VariableCollection original, Cloner cloner) : base(original, cloner) { }
    3033    public VariableCollection() : base() { }
    3134    public VariableCollection(int capacity) : base(capacity) { }
    3235    public VariableCollection(IEnumerable<IVariable> collection) : base(collection) { }
    33     [StorableConstructor]
    34     private VariableCollection(bool deserializing) : base(deserializing) { }
    3536
    3637    public override IDeepCloneable Clone(Cloner cloner) {
    37       VariableCollection clone = new VariableCollection();
    38       cloner.RegisterClonedObject(this, clone);
    39       foreach (string key in dict.Keys)
    40         clone.dict.Add(key, (IVariable)cloner.Clone(dict[key]));
    41       clone.Initialize();
    42       return clone;
     38      return new VariableCollection(this, cloner);
    4339    }
    4440  }
Note: See TracChangeset for help on using the changeset viewer.