Free cookie consent management tool by TermsFeed Policy Generator

source: branches/2521_ProblemRefactoring/HeuristicLab.Data/3.3/ValueTypeArray.cs @ 17309

Last change on this file since 17309 was 17309, checked in by abeham, 4 years ago

#2521: Refactored maximization property for multi-objective problems

File size: 6.9 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections;
24using System.Collections.Generic;
25using System.Drawing;
26using System.Linq;
27using System.Text;
28using HEAL.Attic;
29using HeuristicLab.Common;
30using HeuristicLab.Core;
31
32namespace HeuristicLab.Data {
33  [Item("ValueTypeArray", "An abstract base class for representing arrays of value types.")]
34  [StorableType("6A05E421-E015-44A8-959F-5711CF9400A9")]
35  public abstract class ValueTypeArray<T> : Item, IValueTypeArray<T> where T : struct {
36    private const int maximumToStringLength = 100;
37
38    public static new Image StaticItemImage {
39      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
40    }
41
42    [Storable]
43    protected T[] array;
44
45    [Storable]
46    protected List<string> elementNames;
47    public virtual IEnumerable<string> ElementNames {
48      get { return this.elementNames; }
49      set {
50        if (ReadOnly) throw new NotSupportedException("ElementNames cannot be set. ValueTypeArray is read-only.");
51        if (value == null || !value.Any())
52          elementNames = new List<string>();
53        else if (value.Count() > Length)
54          throw new ArgumentException("The number of element names must not exceed the array length.");
55        else
56          elementNames = new List<string>(value);
57        OnElementNamesChanged();
58      }
59    }
60
61    public virtual int Length {
62      get { return array.Length; }
63      #region Mono Compatibility
64      // this setter should be protected, but the Mono compiler couldn't handle it
65      set {
66        if (ReadOnly) throw new NotSupportedException("Length cannot be set. ValueTypeArray is read-only.");
67        if (value != Length) {
68          Array.Resize<T>(ref array, value);
69          while (elementNames.Count > value)
70            elementNames.RemoveAt(elementNames.Count - 1);
71          OnElementNamesChanged();
72          OnReset();
73        }
74      }
75      #endregion
76    }
77
78    public int Count
79    {
80      get { return Length; }
81    }
82
83    [Storable]
84    protected bool resizable = true;
85    public bool Resizable {
86      get { return resizable; }
87      set {
88        if (resizable != value) {
89          resizable = value;
90          OnResizableChanged();
91        }
92      }
93    }
94
95
96    public virtual T this[int index] {
97      get { return array[index]; }
98      set {
99        if (ReadOnly) throw new NotSupportedException("Item cannot be set. ValueTypeArray is read-only.");
100        if (!value.Equals(array[index])) {
101          array[index] = value;
102          OnItemChanged(index);
103        }
104      }
105    }
106
107    [Storable]
108    protected bool readOnly;
109    public virtual bool ReadOnly {
110      get { return readOnly; }
111    }
112
113    [StorableHook(HookType.AfterDeserialization)]
114    private void AfterDeserialization() {
115      if (elementNames == null) { elementNames = new List<string>(); }
116    }
117
118    [StorableConstructor]
119    protected ValueTypeArray(StorableConstructorFlag _) : base(_) { }
120    protected ValueTypeArray(ValueTypeArray<T> original, Cloner cloner)
121      : base(original, cloner) {
122      this.array = (T[])original.array.Clone();
123      this.readOnly = original.readOnly;
124      this.resizable = original.resizable;
125      this.elementNames = new List<string>(original.elementNames);
126    }
127    protected ValueTypeArray() {
128      array = new T[0];
129      readOnly = false;
130      resizable = true;
131      elementNames = new List<string>();
132    }
133    protected ValueTypeArray(int length) {
134      array = new T[length];
135      readOnly = false;
136      resizable = true;
137      elementNames = new List<string>();
138    }
139    protected ValueTypeArray(T[] elements, bool @readonly = false) {
140      if (elements == null) throw new ArgumentNullException(nameof(elements));
141      array = (T[])elements.Clone();
142      readOnly = @readonly;
143      resizable = true;
144      elementNames = new List<string>();
145    }
146   
147    protected ValueTypeArray(IReadOnlyList<T> elements) {
148      if (elements == null) throw new ArgumentNullException(nameof(elements));
149      array = elements.ToArray(); // TODO: array should be an IList<T>
150      readOnly = true;
151      resizable = true; // TODO: really?
152      elementNames = new List<string>(); // TODO: wasteful
153    }
154
155    public virtual IValueTypeArray AsReadOnly() {
156      if (ReadOnly) return this;
157      var clone = (ValueTypeArray<T>)this.Clone();
158      clone.readOnly = true;
159      return clone;
160    }
161
162    public T[] CloneAsArray() {
163      //mkommend: this works because T must be a value type (struct constraint);
164      return (T[])array.Clone();
165    }
166
167    public override string ToString() {
168      if (array.Length == 0) return "[]";
169
170      StringBuilder sb = new StringBuilder();
171      sb.Append("[");
172      sb.Append(array[0].ToString());
173      for (int i = 1; i < array.Length; i++) {
174        sb.Append(";").Append(array[i].ToString());
175        if (sb.Length > maximumToStringLength) {
176          sb.Append("...");
177          break;
178        }
179      }
180      sb.Append("]");
181      return sb.ToString();
182    }
183
184    public virtual IEnumerator<T> GetEnumerator() {
185      return array.Cast<T>().GetEnumerator();
186    }
187
188    IEnumerator IEnumerable.GetEnumerator() {
189      return GetEnumerator();
190    }
191
192    public event EventHandler ResizableChanged;
193    protected virtual void OnResizableChanged() {
194      EventHandler handler = ResizableChanged;
195      if (handler != null)
196        handler(this, EventArgs.Empty);
197    }
198    public event EventHandler ElementNamesChanged;
199    protected virtual void OnElementNamesChanged() {
200      EventHandler handler = ElementNamesChanged;
201      if (handler != null)
202        handler(this, EventArgs.Empty);
203    }
204
205    public event EventHandler<EventArgs<int>> ItemChanged;
206    protected virtual void OnItemChanged(int index) {
207      if (ItemChanged != null)
208        ItemChanged(this, new EventArgs<int>(index));
209      if (index < maximumToStringLength)
210        OnToStringChanged();
211    }
212    public event EventHandler Reset;
213    protected virtual void OnReset() {
214      if (Reset != null)
215        Reset(this, EventArgs.Empty);
216      OnToStringChanged();
217    }
218  }
219}
Note: See TracBrowser for help on using the repository browser.