Changeset 10586 for branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3

Timestamp:

03/12/14 17:03:45 (11 years ago)

Author:

tsteinre

Message:

• divided/refactored PreprocessingData into TransactionalPreprocessingData and preprocessingData

Location:

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3

Files:

• HeuristicLab.DataPreprocessing-3.3.csproj (modified) (4 diffs)
• Implementations/DataGridLogic.cs (modified) (1 diff)
• Implementations/HistogramLogic.cs (modified) (1 diff)
• Implementations/LineChartLogic.cs (modified) (1 diff)
• Implementations/ManipulationLogic.cs (modified) (1 diff)
• Implementations/PreprocessingContext.cs (modified) (2 diffs)
• Implementations/PreprocessingData.cs (copied) (copied from branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingData.cs) (7 diffs)
• Implementations/SearchLogic.cs (modified) (1 diff)
• Implementations/StatisticsLogic.cs (modified) (1 diff)
• Implementations/TransactionalPreprocessingData.cs (copied) (copied from branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingData.cs) (3 diffs)
• Implementations/TransformationLogic.cs (modified) (1 diff)
• Interfaces/IPreprocessingContext.cs (modified) (1 diff)
• Interfaces/IPreprocessingData.cs (copied) (copied from branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingData.cs) (1 diff)
• Interfaces/ITransactionalPreprocessingData.cs (copied) (copied from branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingData.cs) (1 diff)

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/HeuristicLab.DataPreprocessing-3.3.csproj

@@ -71 +71 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Implementations\PreprocessingData.cs" />
     <Compile Include="Implementations\DataGridLogic.cs" />
     <Compile Include="Implementations\DataPreprocessingChangedEvent.cs" />
@@ -76 +77 @@
     <Compile Include="Implementations\Filter\IFilter.cs" />
     <Compile Include="Implementations\ManipulationLogic.cs" />
+    <Compile Include="Interfaces\IPreprocessingData.cs" />
     <Compile Include="Interfaces\IDataGridLogic.cs" />
     <Compile Include="Implementations\FilterContent.cs" />
@@ -95 +97 @@
     <Compile Include="Implementations\DataGridContent.cs" />
     <Compile Include="Implementations\PreprocessingContext.cs" />
-    <Compile Include="Implementations\PreprocessingData.cs" />
+    <Compile Include="Implementations\TransactionalPreprocessingData.cs" />
     <Compile Include="Implementations\SearchLogic.cs" />
     <Compile Include="Implementations\StatisticsLogic.cs" />
@@ -102 +104 @@
     <Compile Include="Interfaces\ISearchLogic.cs" />
     <Compile Include="Interfaces\IStatisticsLogic.cs" />
-    <Compile Include="Interfaces\IPreprocessingData.cs" />
+    <Compile Include="Interfaces\ITransactionalPreprocessingData.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/DataGridLogic.cs

@@ -29 +29 @@
   public class DataGridLogic : IDataGridLogic {
 
-    private IPreprocessingData preprocessingData;
+    private ITransactionalPreprocessingData preprocessingData;
 
-    public DataGridLogic(IPreprocessingData preprocessingData) {
+    public DataGridLogic(ITransactionalPreprocessingData preprocessingData) {
       this.preprocessingData = preprocessingData;
     }

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/HistogramLogic.cs

@@ -26 +26 @@
 namespace HeuristicLab.DataPreprocessing {
   public class HistogramLogic : IHistogramLogic {
-    private IPreprocessingData preprocessingData;
+    private ITransactionalPreprocessingData preprocessingData;
     private DataTable dataTable;
 
-    public HistogramLogic(IPreprocessingData preprocessingData) {
+    public HistogramLogic(ITransactionalPreprocessingData preprocessingData) {
       this.preprocessingData = preprocessingData;
       dataTable = new DataTable("Histogram");

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/LineChartLogic.cs

@@ -26 +26 @@
 namespace HeuristicLab.DataPreprocessing {
   public class LineChartLogic : ILineChartLogic {
-    private IPreprocessingData preprocessingData;
+    private ITransactionalPreprocessingData preprocessingData;
     private DataTable dataTable;
 
-    public LineChartLogic(IPreprocessingData preprocessingData) {
+    public LineChartLogic(ITransactionalPreprocessingData preprocessingData) {
       this.preprocessingData = preprocessingData;
       dataTable = new DataTable("LineChart");

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/ManipulationLogic.cs

@@ -27 +27 @@
 namespace HeuristicLab.DataPreprocessing {
   public class ManipulationLogic : IManipulationLogic {
-    private IPreprocessingData preprocessingData;
+    private ITransactionalPreprocessingData preprocessingData;
     private IStatisticsLogic statisticInfo;
     private ISearchLogic searchLogic;
 
-    public ManipulationLogic(IPreprocessingData _prepocessingData, ISearchLogic theSearchLogic, IStatisticsLogic theStatisticsLogic) {
+    public ManipulationLogic(ITransactionalPreprocessingData _prepocessingData, ISearchLogic theSearchLogic, IStatisticsLogic theStatisticsLogic) {
       preprocessingData = _prepocessingData;
       searchLogic = theSearchLogic;

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/PreprocessingContext.cs

@@ -32 +32 @@
 
     public PreprocessingContext(IDataAnalysisProblemData dataAnalysisProblemData, IAlgorithm algorithm, IDataAnalysisProblem problem) {
-      Data = new PreprocessingData(dataAnalysisProblemData);
+      Data = new TransactionalPreprocessingData(dataAnalysisProblemData);
       DataAnalysisProblemData = dataAnalysisProblemData;
       Algorithm = algorithm;
@@ -46 +46 @@
     }
 
-    public IPreprocessingData Data { get; private set; }
+    public ITransactionalPreprocessingData Data { get; private set; }
 
     public IDataAnalysisProblemData DataAnalysisProblemData { get; private set; }

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

@@ -31 +31 @@
 namespace HeuristicLab.DataPreprocessing {
 
-  internal class PDSnapshot {
-    public IDictionary<int, IList> VariableValues { get; set; }
-
-    public IList<string> VariableNames { get; set; }
-
-    public double TrainingToTestRatio { get; set; }
-
-    public DataPreprocessingChangedEventType ChangedType { get; set; }
-
-    public int ChangedColumn { get; set; }
-
-    public int ChangedRow { get; set; }
-  }
-
   [Item("PreprocessingData", "Represents data used for preprocessing.")]
   public class PreprocessingData : NamedItem, IPreprocessingData {
 
-    private const int MAX_UNDO_DEPTH = 5;
-
-    private IDictionary<int, IList> variableValues;
-
-    private IList<string> variableNames;
-
-    private double trainingToTestRatio;
-
-    private IList<PDSnapshot> undoHistory;
-
-    //TODO: refactor extract Transaction logic in a own class
-    private int transactionDepth = 0;
-
-    private PreprocessingData(PreprocessingData original, Cloner cloner)
+    protected IDictionary<int, IList> variableValues;
+
+    protected IList<string> variableNames;
+
+    protected double trainingToTestRatio;
+
+    protected PreprocessingData(PreprocessingData original, Cloner cloner)
       : base(original, cloner) {
       variableValues = CopyVariableValues(original.variableValues);
       variableNames = new List<string>(original.variableNames);
       trainingToTestRatio = original.trainingToTestRatio;
-      undoHistory = new List<PDSnapshot>();
     }
 
@@ -92 +70 @@
 
       trainingToTestRatio = (double)problemData.TrainingPartition.Size / Math.Max(problemData.Dataset.Rows, double.Epsilon);
-      undoHistory = new List<PDSnapshot>();
     }
 
@@ -103 +80 @@
     }
 
-    private IDictionary<int, IList> CopyVariableValues(IDictionary<int, IList> original) {
+    protected IDictionary<int, IList> CopyVariableValues(IDictionary<int, IList> original) {
       var copy = new Dictionary<int, IList>(variableValues);
       for (int i = 0; i < original.Count; i++) {
@@ -111 +88 @@
     }
 
-    private void SaveSnapshot(DataPreprocessingChangedEventType changedType, int column, int row) {
-      if (transactionDepth > 0) return;
-
-      PDSnapshot currentSnapshot = new PDSnapshot();
-      currentSnapshot.VariableValues = CopyVariableValues(variableValues);
-      currentSnapshot.VariableNames = new List<string>(variableNames);
-      currentSnapshot.TrainingToTestRatio = trainingToTestRatio;
-      currentSnapshot.ChangedType = changedType;
-      currentSnapshot.ChangedColumn = column;
-      currentSnapshot.ChangedRow = row;
-
-      if (undoHistory.Count >= MAX_UNDO_DEPTH)
-        undoHistory.RemoveAt(0);
-
-      undoHistory.Add(currentSnapshot);
-    }
-
     #region NamedItem abstract Member Implementations
 
@@ -143 +103 @@
 
 
-    public void SetCell<T>(int columnIndex, int rowIndex, T value) {
-      SaveSnapshot(DataPreprocessingChangedEventType.ChangeItem, columnIndex, rowIndex);
+    public virtual void SetCell<T>(int columnIndex, int rowIndex, T value) {
       variableValues[columnIndex][rowIndex] = value;
-      if (transactionDepth <= 0)
-        OnChanged(DataPreprocessingChangedEventType.ChangeItem, columnIndex, rowIndex);
     }
 
@@ -165 +122 @@
     }
 
-    public void SetValues<T>(int columnIndex, IList<T> values) {
+    public virtual void SetValues<T>(int columnIndex, IList<T> values) {
       if (IsType<T>(columnIndex)) {
-        SaveSnapshot(DataPreprocessingChangedEventType.ChangeColumn, columnIndex, -1);
         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 (transactionDepth <= 0)
-        OnChanged(DataPreprocessingChangedEventType.ChangeColumn, columnIndex, -1);
-    }
-
-    public void InsertRow(int rowIndex) {
-      SaveSnapshot(DataPreprocessingChangedEventType.DeleteRow, -1, rowIndex);
+    }
+
+    public virtual void InsertRow(int rowIndex) {
       foreach (IList column in variableValues.Values) {
         Type type = column.GetType().GetGenericArguments()[0];
         column.Insert(rowIndex, type.IsValueType ? Activator.CreateInstance(type) : null);
       }
-      if (transactionDepth <= 0)
-        OnChanged(DataPreprocessingChangedEventType.AddRow, -1, rowIndex);
-    }
-
-    public void DeleteRow(int rowIndex) {
-      SaveSnapshot(DataPreprocessingChangedEventType.AddRow, -1, rowIndex);
+    }
+
+    public virtual void DeleteRow(int rowIndex) {
       foreach (IList column in variableValues.Values) {
         column.RemoveAt(rowIndex);
       }
-      if (transactionDepth <= 0)
-        OnChanged(DataPreprocessingChangedEventType.DeleteRow, -1, rowIndex);
-    }
-
-    public void InsertColumn<T>(string variableName, int columnIndex) {
-      SaveSnapshot(DataPreprocessingChangedEventType.DeleteColumn, columnIndex, -1);
+    }
+
+    public virtual void InsertColumn<T>(string variableName, int columnIndex) {
       variableValues.Add(columnIndex, new List<T>(Rows));
       variableNames.Insert(columnIndex, variableName);
-      if (transactionDepth <= 0)
-        OnChanged(DataPreprocessingChangedEventType.AddColumn, columnIndex, -1);
-    }
-
-    public void DeleteColumn(int columnIndex) {
-      SaveSnapshot(DataPreprocessingChangedEventType.AddColumn, columnIndex, -1);
+    }
+
+    public virtual void DeleteColumn(int columnIndex) {
       variableValues.Remove(columnIndex);
       variableNames.RemoveAt(columnIndex);
-      if (transactionDepth <= 0)
-        OnChanged(DataPreprocessingChangedEventType.DeleteColumn, columnIndex, -1);
     }
 
@@ -252 +194 @@
       var dataset = new Dataset(variableNames, values);
       return dataset;
-    }
-
-    public event DataPreprocessingChangedEventHandler Changed;
-    protected virtual void OnChanged(DataPreprocessingChangedEventType type, int column, int row) {
-      var listeners = Changed;
-      if (listeners != null) listeners(this, new DataPreprocessingChangedEventArgs(type, column, row));
-    }
-
-    public bool IsUndoAvailable {
-      get { return undoHistory.Count > 0; }
-    }
-
-    public void Undo() {
-      if (IsUndoAvailable) {
-        PDSnapshot previousSnapshot = undoHistory[undoHistory.Count - 1];
-        variableValues = previousSnapshot.VariableValues;
-        variableNames = previousSnapshot.VariableNames;
-        trainingToTestRatio = previousSnapshot.TrainingToTestRatio;
-        undoHistory.Remove(previousSnapshot);
-        OnChanged(previousSnapshot.ChangedType,
-          previousSnapshot.ChangedColumn,
-          previousSnapshot.ChangedRow);
-      }
-    }
-
-    public void BeginTransaction() {
-      SaveSnapshot(DataPreprocessingChangedEventType.Any, -1, -1);
-      transactionDepth++;
-    }
-
-    public void EndTransaction() {
-      transactionDepth--;
-      if (transactionDepth < 0)
-        throw new InvalidOperationException("There is no open transaction that can be ended.");
-      if (transactionDepth == 0)
-        OnChanged(DataPreprocessingChangedEventType.Any, -1, -1);
     }
 

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/SearchLogic.cs

@@ -26 +26 @@
 namespace HeuristicLab.DataPreprocessing {
   public class SearchLogic : ISearchLogic {
-    private readonly IPreprocessingData preprocessingData;
+    private readonly ITransactionalPreprocessingData preprocessingData;
 
-    public SearchLogic(IPreprocessingData thePreprocessingData) {
+    public SearchLogic(ITransactionalPreprocessingData thePreprocessingData) {
       preprocessingData = thePreprocessingData;
     }

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/StatisticsLogic.cs

@@ -29 +29 @@
   public class StatisticsLogic : IStatisticsLogic {
 
-    private readonly IPreprocessingData preprocessingData;
+    private readonly ITransactionalPreprocessingData preprocessingData;
     private readonly ISearchLogic searchLogic;
 
-    public StatisticsLogic(IPreprocessingData thePreprocessingData, ISearchLogic theSearchLogic) {
+    public StatisticsLogic(ITransactionalPreprocessingData thePreprocessingData, ISearchLogic theSearchLogic) {
       preprocessingData = thePreprocessingData;
       searchLogic = theSearchLogic;

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

@@ -23 +23 @@
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -46 +44 @@
 
   [Item("PreprocessingData", "Represents data used for preprocessing.")]
-  public class PreprocessingData : NamedItem, IPreprocessingData {
+  public class TransactionalPreprocessingData : PreprocessingData, ITransactionalPreprocessingData {
 
     private const int MAX_UNDO_DEPTH = 5;
 
-    private IDictionary<int, IList> variableValues;
-
-    private IList<string> variableNames;
-
-    private double trainingToTestRatio;
-
     private IList<PDSnapshot> undoHistory;
 
-    //TODO: refactor extract Transaction logic in a own class
     private int transactionDepth = 0;
 
-    private PreprocessingData(PreprocessingData original, Cloner cloner)
+    private TransactionalPreprocessingData(TransactionalPreprocessingData original, Cloner cloner)
       : base(original, cloner) {
-      variableValues = CopyVariableValues(original.variableValues);
-      variableNames = new List<string>(original.variableNames);
-      trainingToTestRatio = original.trainingToTestRatio;
       undoHistory = new List<PDSnapshot>();
     }
 
-    public PreprocessingData(IDataAnalysisProblemData problemData)
-      : base() {
-      Name = "-";
-
-      variableNames = new List<string>(problemData.Dataset.VariableNames);
-      // create dictionary from variable name to index
-
-      int columnIndex = 0;
-      variableValues = new Dictionary<int, IList>();
-      foreach (var variableName in problemData.Dataset.VariableNames) {
-        if (problemData.Dataset.IsType<double>(variableName)) {
-          variableValues[columnIndex] = problemData.Dataset.GetDoubleValues(variableName).ToList();
-        } else if (problemData.Dataset.IsType<string>(variableName)) {
-          variableValues[columnIndex] = CreateColumn<string>(problemData.Dataset, columnIndex, x => x);
-        } else if (problemData.Dataset.IsType<DateTime>(variableName)) {
-          variableValues[columnIndex] = CreateColumn<DateTime>(problemData.Dataset, columnIndex, x => DateTime.Parse(x));
-        } else {
-          throw new ArgumentException("The datatype of column " + variableName + " must be of type List<double>, List<string> or List<DateTime>");
-        }
-        ++columnIndex;
-      }
-
-      trainingToTestRatio = (double)problemData.TrainingPartition.Size / Math.Max(problemData.Dataset.Rows, double.Epsilon);
+    public TransactionalPreprocessingData(IDataAnalysisProblemData problemData)
+      : base(problemData) {
       undoHistory = new List<PDSnapshot>();
-    }
-
-    private static IList CreateColumn<T>(Dataset ds, int column, Func<string, T> selector) {
-      var list = new List<T>(ds.Rows);
-      for (int row = 0; row < ds.Rows; ++row) {
-        list.Add(selector(ds.GetValue(row, column)));
-      }
-      return list;
-    }
-
-    private IDictionary<int, IList> CopyVariableValues(IDictionary<int, IList> original) {
-      var copy = new Dictionary<int, IList>(variableValues);
-      for (int i = 0; i < original.Count; i++) {
-        variableValues[i] = (IList)Activator.CreateInstance(original[i].GetType(), original[i]);
-      }
-      return copy;
     }
 
@@ -131 +82 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new PreprocessingData(this, cloner);
+      return new TransactionalPreprocessingData(this, cloner);
     }
 
     #endregion
 
-    #region IPreprocessingData Members
+    #region Overridden IPreprocessingData Members
 
-    public T GetCell<T>(int columnIndex, int rowIndex) {
-      return (T)variableValues[columnIndex][rowIndex];
-    }
-
-
-    public void SetCell<T>(int columnIndex, int rowIndex, T value) {
+    public override void SetCell<T>(int columnIndex, int rowIndex, T value) {
       SaveSnapshot(DataPreprocessingChangedEventType.ChangeItem, columnIndex, rowIndex);
-      variableValues[columnIndex][rowIndex] = value;
+      base.SetCell<T>(columnIndex, rowIndex, value);
       if (transactionDepth <= 0)
         OnChanged(DataPreprocessingChangedEventType.ChangeItem, columnIndex, rowIndex);
     }
 
-
-    public string GetCellAsString(int columnIndex, int rowIndex) {
-      return variableValues[columnIndex][rowIndex].ToString();
-    }
-
-
-    [Obsolete("use the index based variant, is faster")]
-    public IList<T> GetValues<T>(string variableName) {
-      return GetValues<T>(GetColumnIndex(variableName));
-    }
-
-    public IList<T> GetValues<T>(int columnIndex) {
-      return (IList<T>)variableValues[columnIndex];
-    }
-
-    public void SetValues<T>(int columnIndex, IList<T> values) {
-      if (IsType<T>(columnIndex)) {
-        SaveSnapshot(DataPreprocessingChangedEventType.ChangeColumn, columnIndex, -1);
-        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 override void SetValues<T>(int columnIndex, IList<T> values) {
+      SaveSnapshot(DataPreprocessingChangedEventType.ChangeColumn, columnIndex, -1);
+      base.SetValues<T>(columnIndex, values);
       if (transactionDepth <= 0)
         OnChanged(DataPreprocessingChangedEventType.ChangeColumn, columnIndex, -1);
     }
 
-    public void InsertRow(int rowIndex) {
+    public override void InsertRow(int rowIndex) {
       SaveSnapshot(DataPreprocessingChangedEventType.DeleteRow, -1, rowIndex);
-      foreach (IList column in variableValues.Values) {
-        Type type = column.GetType().GetGenericArguments()[0];
-        column.Insert(rowIndex, type.IsValueType ? Activator.CreateInstance(type) : null);
-      }
+      base.InsertRow(rowIndex);
       if (transactionDepth <= 0)
         OnChanged(DataPreprocessingChangedEventType.AddRow, -1, rowIndex);
     }
 
-    public void DeleteRow(int rowIndex) {
+    public override void DeleteRow(int rowIndex) {
       SaveSnapshot(DataPreprocessingChangedEventType.AddRow, -1, rowIndex);
-      foreach (IList column in variableValues.Values) {
-        column.RemoveAt(rowIndex);
-      }
+      base.DeleteRow(rowIndex);
       if (transactionDepth <= 0)
         OnChanged(DataPreprocessingChangedEventType.DeleteRow, -1, rowIndex);
     }
 
-    public void InsertColumn<T>(string variableName, int columnIndex) {
+    public override void InsertColumn<T>(string variableName, int columnIndex) {
       SaveSnapshot(DataPreprocessingChangedEventType.DeleteColumn, columnIndex, -1);
-      variableValues.Add(columnIndex, new List<T>(Rows));
-      variableNames.Insert(columnIndex, variableName);
+      base.InsertColumn<T>(variableName, columnIndex);
       if (transactionDepth <= 0)
         OnChanged(DataPreprocessingChangedEventType.AddColumn, columnIndex, -1);
     }
 
-    public void DeleteColumn(int columnIndex) {
+    public override void DeleteColumn(int columnIndex) {
       SaveSnapshot(DataPreprocessingChangedEventType.AddColumn, columnIndex, -1);
-      variableValues.Remove(columnIndex);
-      variableNames.RemoveAt(columnIndex);
+      base.DeleteColumn(columnIndex);
       if (transactionDepth <= 0)
         OnChanged(DataPreprocessingChangedEventType.DeleteColumn, columnIndex, -1);
     }
 
-    public IntRange TrainingPartition {
-      get { return new IntRange(0, (int)(Rows * trainingToTestRatio)); }
-    }
+    #endregion
 
-    public IntRange TestPartition {
-      get { return new IntRange((int)(Rows * trainingToTestRatio), Rows); }
-    }
-
-    public string GetVariableName(int columnIndex) {
-      return variableNames[columnIndex];
-    }
-
-    public IEnumerable<string> VariableNames {
-      get { return variableNames; }
-    }
-
-    public int GetColumnIndex(string variableName) {
-      return variableNames.IndexOf(variableName);
-    }
-
-    public bool IsType<T>(int columnIndex) {
-      return variableValues[columnIndex] is List<T>;
-    }
-
-    public int Columns {
-      get { return variableNames.Count; }
-    }
-
-    public int Rows {
-      get { return variableValues.Count > 0 ? variableValues[0].Count : 0; }
-    }
-
-    public 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;
-    }
+    #region TransactionalPreprocessingData members
 
     public event DataPreprocessingChangedEventHandler Changed;

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/TransformationLogic.cs

@@ -26 +26 @@
   public class TransformationLogic : ITransformationLogic {
 
-    private readonly IPreprocessingData preprocessingData;
+    private readonly ITransactionalPreprocessingData preprocessingData;
     private readonly ISearchLogic searchLogic;
     private readonly IStatisticsLogic statisticsLogic;
 
-    public TransformationLogic(IPreprocessingData thePreprocessingData, ISearchLogic theSearchLogic, IStatisticsLogic theStatisticsLogic) {
+    public TransformationLogic(ITransactionalPreprocessingData thePreprocessingData, ISearchLogic theSearchLogic, IStatisticsLogic theStatisticsLogic) {
       preprocessingData = thePreprocessingData;
       searchLogic = theSearchLogic;

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingContext.cs

@@ -29 +29 @@
     : IItem {
 
-    IPreprocessingData Data { get; }
+    ITransactionalPreprocessingData Data { get; }
 
     [Obsolete]

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IPreprocessingData.cs

@@ -61 +61 @@
 
     Dataset ExportToDataset();
-
-    event DataPreprocessingChangedEventHandler Changed;
-
-    bool IsUndoAvailable { get; }
-    void Undo();
-    void BeginTransaction();
-    void EndTransaction();
   }
 }

branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/ITransactionalPreprocessingData.cs

@@ -20 +20 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.DataPreprocessing {
 
-  public interface IPreprocessingData : INamedItem {
-    T GetCell<T>(int columnIndex, int rowIndex);
-
-    void SetCell<T>(int columnIndex, int rowIndex, T value);
-
-    string GetCellAsString(int columnIndex, int rowIndex);
-
-    [Obsolete("use the index based variant, is faster")]
-    IList<T> GetValues<T>(string variableName);
-    IList<T> GetValues<T>(int columnIndex);
-
-    void SetValues<T>(int columnIndex, IList<T> values);
-
-    void InsertRow(int rowIndex);
-    void DeleteRow(int rowIndex);
-
-    void InsertColumn<T>(string variableName, int columnIndex);
-
-    void DeleteColumn(int columnIndex);
-
-    IntRange TrainingPartition { get; }
-    IntRange TestPartition { get; }
-
-    IEnumerable<string> VariableNames { get; }
-    string GetVariableName(int columnIndex);
-    int GetColumnIndex(string variableName);
-
-    bool IsType<T>(int columnIndex);
-
-    int Columns { get; }
-    int Rows { get; }
-
-    Dataset ExportToDataset();
+  public interface ITransactionalPreprocessingData : IPreprocessingData {
 
     event DataPreprocessingChangedEventHandler Changed;