Changeset 10991

Timestamp:

06/11/14 14:48:26 (10 years ago)

Author:

psteiner

Message:

abstract PreprocessingData

Location:

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations

Files:

• PreprocessingData.cs (modified) (1 diff)
• TransactionalPreprocessingData.cs (modified) (5 diffs)

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingData.cs

@@ -126 +126 @@
     #region IPreprocessingData Members
 
-    public T GetCell<T>(int columnIndex, int rowIndex) {
-      return (T)variableValues[columnIndex][rowIndex];
-    }
+    public abstract T GetCell<T>(int columnIndex, int rowIndex);
 
-    public virtual void SetCell<T>(int columnIndex, int rowIndex, T value) {
-      variableValues[columnIndex][rowIndex] = value;
-    }
+    public abstract void SetCell<T>(int columnIndex, int rowIndex, T value);
 
-    public string GetCellAsString(int columnIndex, int rowIndex) {
-      return variableValues[columnIndex][rowIndex].ToString();
-    }
+    public abstract string GetCellAsString(int columnIndex, int rowIndex);
 
-    public string GetVariableName(int columnIndex) {
-      return variableNames[columnIndex];
-    }
+    public abstract string GetVariableName(int columnIndex);
 
-    public int GetColumnIndex(string variableName) {
-      return variableNames.IndexOf(variableName);
-    }
+    public abstract int GetColumnIndex(string variableName);
 
-    public bool IsType<T>(int columnIndex) {
-      return variableValues[columnIndex] is List<T>;
-    }
+    public abstract bool IsType<T>(int columnIndex);
 
     [Obsolete("use the index based variant, is faster")]
-    public IList<T> GetValues<T>(string variableName, bool considerSelection) {
-      return GetValues<T>(GetColumnIndex(variableName), considerSelection);
-    }
+    public abstract IList<T> GetValues<T>(string variableName, bool considerSelection);
 
-    public IList<T> GetValues<T>(int columnIndex, bool considerSelection) {
-      if (considerSelection) {
-        var list = new List<T>();
-        foreach (var rowIdx in selection[columnIndex]) {
-          list.Add((T)variableValues[columnIndex][rowIdx]);
-        }
-        return list;
-      } else {
-        return (IList<T>)variableValues[columnIndex];
-      }
-    }
+    public abstract IList<T> GetValues<T>(int columnIndex, bool considerSelection);
 
-    public virtual void SetValues<T>(int columnIndex, IList<T> values) {
-      if (IsType<T>(columnIndex)) {
-        variableValues[columnIndex] = (IList)values;
-      } else {
-        throw new ArgumentException("The datatype of column " + columnIndex + " must be of type " + variableValues[columnIndex].GetType().Name + " but was " + typeof(T).Name);
-      }
-    }
+    public abstract void SetValues<T>(int columnIndex, IList<T> values);
 
-    public virtual void InsertRow(int rowIndex) {
-      foreach (IList column in variableValues) {
-        Type type = column.GetType().GetGenericArguments()[0];
-        column.Insert(rowIndex, type.IsValueType ? Activator.CreateInstance(type) : null);
-      }
-    }
+    public abstract void InsertRow(int rowIndex);
 
-    public virtual void DeleteRow(int rowIndex) {
-      foreach (IList column in variableValues) {
-        column.RemoveAt(rowIndex);
-      }
-    }
+    public abstract void DeleteRow(int rowIndex);
 
-    public virtual void InsertColumn<T>(string variableName, int columnIndex) {
-      variableValues.Insert(columnIndex, new List<T>(Rows));
-      variableNames.Insert(columnIndex, variableName);
-    }
+    public abstract void InsertColumn<T>(string variableName, int columnIndex);
 
-    public virtual void DeleteColumn(int columnIndex) {
-      variableValues.RemoveAt(columnIndex);
-      variableNames.RemoveAt(columnIndex);
-    }
+    public abstract void DeleteColumn(int columnIndex);
 
-    public Dataset ExportToDataset() {
-      IList<IList> values = new List<IList>();
+    public abstract Dataset ExportToDataset();
 
-      for (int i = 0; i < Columns; ++i) {
-        values.Add(variableValues[i]);
-      }
+    public abstract void ClearSelection();
 
-      var dataset = new Dataset(variableNames, values);
-      return dataset;
-    }
-
-    public void ClearSelection() {
-      Selection = new Dictionary<int, IList<int>>();
-    }
-
-    public event EventHandler SelectionChanged;
-    protected virtual void OnSelectionChanged() { 
-       var listeners = SelectionChanged;
-       if (listeners != null) listeners(this, EventArgs.Empty);
-    }
+    public abstract event EventHandler SelectionChanged;
+    protected abstract void OnSelectionChanged();
 
     public event DataPreprocessingChangedEventHandler Changed;
-    protected virtual void OnChanged(DataPreprocessingChangedEventType type, int column, int row) {
+    protected virtual void OnChanged(DataPreprocessingChangedEventType type, int column, int row)
+    {
       var listeners = Changed;
       if (listeners != null) listeners(this, new DataPreprocessingChangedEventArgs(type, column, row));

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/TransactionalPreprocessingData.cs

@@ -89 +89 @@
     #region Overridden IPreprocessingData Members
 
+    public override T GetCell<T>(int columnIndex, int rowIndex)
+    {
+      return (T)variableValues[columnIndex][rowIndex];
+    }
+
     public override void SetCell<T>(int columnIndex, int rowIndex, T value) {
       SaveSnapshot(DataPreprocessingChangedEventType.ChangeItem, columnIndex, rowIndex);
-      base.SetCell<T>(columnIndex, rowIndex, value);
+      variableValues[columnIndex][rowIndex] = value;
       if (!IsInTransaction)
         OnChanged(DataPreprocessingChangedEventType.ChangeItem, columnIndex, rowIndex);
+    }
+
+    public override string GetCellAsString(int columnIndex, int rowIndex)
+    {
+      return variableValues[columnIndex][rowIndex].ToString();
+    }
+
+    public override string GetVariableName(int columnIndex)
+    {
+      return variableNames[columnIndex];
+    }
+
+    public override int GetColumnIndex(string variableName)
+    {
+      return variableNames.IndexOf(variableName);
+    }
+
+    public override bool IsType<T>(int columnIndex)
+    {
+      return variableValues[columnIndex] is List<T>;
+    }
+
+    [Obsolete("use the index based variant, is faster")]
+    public override IList<T> GetValues<T>(string variableName, bool considerSelection)
+    {
+      return GetValues<T>(GetColumnIndex(variableName), considerSelection);
+    }
+
+    public override IList<T> GetValues<T>(int columnIndex, bool considerSelection)
+    {
+      if (considerSelection)
+      {
+        var list = new List<T>();
+        foreach (var rowIdx in selection[columnIndex])
+        {
+          list.Add((T)variableValues[columnIndex][rowIdx]);
+        }
+        return list;
+      }
+      else
+      {
+        return (IList<T>)variableValues[columnIndex];
+      }
     }
 
     public override void SetValues<T>(int columnIndex, IList<T> values) {
       SaveSnapshot(DataPreprocessingChangedEventType.ChangeColumn, columnIndex, -1);
-      base.SetValues<T>(columnIndex, values);
+      if (IsType<T>(columnIndex))
+      {
+        variableValues[columnIndex] = (IList)values;
+      }
+      else
+      {
+        throw new ArgumentException("The datatype of column " + columnIndex + " must be of type " + variableValues[columnIndex].GetType().Name + " but was " + typeof(T).Name);
+      }
       if (!IsInTransaction)
         OnChanged(DataPreprocessingChangedEventType.ChangeColumn, columnIndex, -1);
@@ -105 +160 @@
     public override void InsertRow(int rowIndex) {
       SaveSnapshot(DataPreprocessingChangedEventType.DeleteRow, -1, rowIndex);
-      base.InsertRow(rowIndex);
+      foreach (IList column in variableValues)
+      {
+        Type type = column.GetType().GetGenericArguments()[0];
+        column.Insert(rowIndex, type.IsValueType ? Activator.CreateInstance(type) : null);
+      }
       if (!IsInTransaction)
         OnChanged(DataPreprocessingChangedEventType.AddRow, -1, rowIndex);
@@ -112 +171 @@
     public override void DeleteRow(int rowIndex) {
       SaveSnapshot(DataPreprocessingChangedEventType.AddRow, -1, rowIndex);
-      base.DeleteRow(rowIndex);
+      foreach (IList column in variableValues)
+      {
+        column.RemoveAt(rowIndex);
+      }
       if (!IsInTransaction)
         OnChanged(DataPreprocessingChangedEventType.DeleteRow, -1, rowIndex);
@@ -119 +181 @@
     public override void InsertColumn<T>(string variableName, int columnIndex) {
       SaveSnapshot(DataPreprocessingChangedEventType.DeleteColumn, columnIndex, -1);
-      base.InsertColumn<T>(variableName, columnIndex);
+      variableValues.Insert(columnIndex, new List<T>(Rows));
+      variableNames.Insert(columnIndex, variableName);
       if (!IsInTransaction)
         OnChanged(DataPreprocessingChangedEventType.AddColumn, columnIndex, -1);
@@ -126 +189 @@
     public override void DeleteColumn(int columnIndex) {
       SaveSnapshot(DataPreprocessingChangedEventType.AddColumn, columnIndex, -1);
-      base.DeleteColumn(columnIndex);
+      variableValues.RemoveAt(columnIndex);
+      variableNames.RemoveAt(columnIndex);
       if (!IsInTransaction)
         OnChanged(DataPreprocessingChangedEventType.DeleteColumn, columnIndex, -1);
     }
+
+    public override Dataset ExportToDataset()
+    {
+      IList<IList> values = new List<IList>();
+
+      for (int i = 0; i < Columns; ++i)
+      {
+        values.Add(variableValues[i]);
+      }
+
+      var dataset = new Dataset(variableNames, values);
+      return dataset;
+    }
+
+    public override void ClearSelection()
+    {
+      Selection = new Dictionary<int, IList<int>>();
+    }
+
+    public override event EventHandler SelectionChanged;
+
+    protected override void OnSelectionChanged()
+    {
+      var listeners = SelectionChanged;
+      if (listeners != null) listeners(this, EventArgs.Empty);
+    }
+
 
     #endregion