source: branches/2906_Transformations/HeuristicLab.DataPreprocessing/3.4/Data/PreprocessingTransformation.cs

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.DataPreprocessing {
  [Item("Preprocessing Transformation", "")]
  [StorableClass]
  public class PreprocessingTransformation : ParameterizedNamedItem, INotifyPropertyChanged {
    #region Parameters
    public IConstrainedValueParameter<StringValue> OriginalVariableParameter {
      get { return (IConstrainedValueParameter<StringValue>)Parameters["Original Variable"]; }
    }

    public IConstrainedValueParameter<StringValue> TransformedVariableParameter {
      get { return (IConstrainedValueParameter<StringValue>)Parameters["Transformed Variable"]; }
    }

    public IConstrainedValueParameter<ITransformation> TransformationParameter {
      get { return (IConstrainedValueParameter<ITransformation>)Parameters["Transformation"]; }
    }
    #endregion

    #region Properties
    public string OriginalVariable {
      get { return OriginalVariableParameter.Value.Value; }
      set { SetConstrainedValue(OriginalVariableParameter, value); }
    }

    public string TransformedVariable {
      get { return TransformedVariableParameter.Value.Value; }
      set { SetConstrainedValue(TransformedVariableParameter, value); }
    }

    public ITransformation Transformation {
      get { return TransformationParameter.Value; }
      set { TransformationParameter.Value = value; }
    }

    public bool IsApplied {
      get { return isApplied; }
      set { if (IsApplied != value) { isApplied = value; OnPropertyChanged(); } }
    }
    private bool isApplied;

    private static void SetConstrainedValue(IConstrainedValueParameter<StringValue> parameter, string value, [CallerMemberName] string caller = null) {
      if (value == null) throw new ArgumentNullException(caller);
      if (value == parameter.Value.Value) return;

      var matchingValue = parameter.ValidValues.SingleOrDefault(v => v.Value == value);
      if (matchingValue == null) throw new ArgumentException("The provided value is not valid.", caller);
      parameter.Value = matchingValue;
    }
    #endregion

    #region Constructor, Cloning & Persistence
    public PreprocessingTransformation(IEnumerable<StringValue> variableNames)
      : base() {
      var originalVariables = new ItemSet<StringValue>(variableNames.Select(x => x.AsReadOnly()));
      var transformedVariables = new ItemSet<StringValue>(variableNames.Select(x => x.AsReadOnly()));
      Parameters.Add(new ConstrainedValueParameter<StringValue>("Original Variable", new ItemSet<StringValue>(originalVariables), originalVariables.FirstOrDefault()));
      Parameters.Add(new ConstrainedValueParameter<StringValue>("Transformed Variable", new ItemSet<StringValue>(transformedVariables), transformedVariables.FirstOrDefault()));
      var transformations = new ItemSet<ITransformation>(ApplicationManager.Manager.GetInstances<ITransformation>());
      Parameters.Add(new ConstrainedValueParameter<ITransformation>("Transformation", transformations, transformations.OfType<IdentityTransformation>().Single()));

      IsApplied = false;

      RegisterEventHandlers();
    }

    protected PreprocessingTransformation(PreprocessingTransformation original, Cloner cloner)
      : base(original, cloner) {
      RegisterEventHandlers();
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new PreprocessingTransformation(this, cloner);
    }

    [StorableConstructor]
    protected PreprocessingTransformation(bool deserializing)
      : base(deserializing) { }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      RegisterEventHandlers();
    }
    #endregion

    #region Event-Handling
    private void RegisterEventHandlers() {
      OriginalVariableParameter.ValueChanged += OriginalVariableParameter_ValueChanged;
      TransformedVariableParameter.ValueChanged += TransformedVariableParameter_ValueChanged;
      TransformationParameter.ValueChanged += TransformationParameter_ValueChanged;
    }

    private void OriginalVariableParameter_ValueChanged(object sender, EventArgs e) {
      OriginalVariableParameter.Value.ValueChanged += OriginalVariableParameterValue_ValueChanged;
      OnPropertyChanged(nameof(OriginalVariable));
    }
    private void OriginalVariableParameterValue_ValueChanged(object sender, EventArgs e) {
      OnPropertyChanged(nameof(OriginalVariable));
    }

    private void TransformedVariableParameter_ValueChanged(object sender, EventArgs e) {
      TransformedVariableParameter.Value.ValueChanged += TransformedVariableParameterValue_ValueChanged;
      OnPropertyChanged(nameof(TransformedVariable));
    }
    private void TransformedVariableParameterValue_ValueChanged(object sender, EventArgs e) {
      OnPropertyChanged(nameof(TransformedVariable));
    }

    private void TransformationParameter_ValueChanged(object sender, EventArgs e) {
      OnPropertyChanged(nameof(Transformation));
    }
    #endregion

    public override string ToString() {
      return $"{Transformation} ({OriginalVariable} -> {TransformedVariable})";
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null) {
      OnToStringChanged();
      PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
  }
}