source: branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/RunCollectionModifiers/RunCollectionModifierExecutable.cs @ 11193

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2013 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.Linq;
using System.Threading;
using System.Threading.Tasks;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.MainForm;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Analysis.SolutionCaching {
  [Item("RunCollectionModifierExecutable", "An executable that runs RunCollectionModifiers on RunCollections.")]
  [StorableClass]
  public class RunCollectionModifierExecutable : ParameterizedNamedItem, IExecutable {
    [Storable]
    protected ExecutionState executionState;
    public ExecutionState ExecutionState {
      get { return executionState; }
      set {
        if (value != executionState) {
          executionState = value;
          OnExecutionStateChanged();
        }
      }
    }

    [Storable]
    protected TimeSpan executionTime;
    public TimeSpan ExecutionTime {
      get { return executionTime; }
      set {
        if (value != executionTime) {
          executionTime = value;
          OnExecutionTimeChanged();
        }
      }
    }

    [Storable]
    protected Stack<IRunCollectionModifier> executionStack;
    protected Stack<IRunCollectionModifier> ExecutionStack {
      get { return executionStack; }
    }

    [Storable]
    protected ILog log;
    public ILog Log {
      get { return log; }
    }

    protected CancellationTokenSource cancellationTokenSource;
    protected bool stopPending;
    public IProgress Progress { get; set; }

    public ValueParameter<ItemList<IRunCollectionModifier>> RunCollectionModifiersParameter {
      get { return (ValueParameter<ItemList<IRunCollectionModifier>>)Parameters["RunCollectionModifiers"]; }
    }
    public RunCollection RunCollection {
      get { return RunCollectionParameter.Value; }
      protected set { RunCollectionParameter.Value = value; }
    }
    public ValueParameter<RunCollection> RunCollectionParameter {
      get { return (ValueParameter<RunCollection>)Parameters["RunCollection"]; }
    }
    public ItemList<IRunCollectionModifier> RunCollectionModifiers {
      get { return RunCollectionModifiersParameter.Value; }
    }

    #region Constructors and Cloning
    public RunCollectionModifierExecutable() {
      Parameters.Add(new ValueParameter<ItemList<IRunCollectionModifier>>("RunCollectionModifiers", "List of RunCollectionModifiers that are executed. ", new ItemList<IRunCollectionModifier>()));
      Parameters.Add(new ValueParameter<RunCollection>("RunCollection", "RunCollection on which the modifiers are applied. ", new RunCollection()));
      executionStack = new Stack<IRunCollectionModifier>();
      log = new Log();
      executionState = ExecutionState.Stopped;
    }
    [StorableConstructor]
    protected RunCollectionModifierExecutable(bool deserializing) : base(deserializing) { }
    protected RunCollectionModifierExecutable(RunCollectionModifierExecutable original, Cloner cloner)
      : base(original, cloner) {
      executionTime = original.executionTime;
      executionState = original.executionState;
      executionStack = new Stack<IRunCollectionModifier>();
      foreach (var runCollectionModifier in original.executionStack) {
        executionStack.Push(runCollectionModifier);
      }
      log = (ILog)original.log.Clone(cloner);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new RunCollectionModifierExecutable(this, cloner);
    }

    //special cloning which ignores the RunCollection and the execution stack
    public RunCollectionModifierExecutable CloneWithoutRuns() {
      var clone = new RunCollectionModifierExecutable();
      clone.executionTime = executionTime;
      clone.executionState = executionState;
      clone.log = (ILog)log.Clone(new Cloner());
      clone.RunCollectionModifiersParameter.Value = (ItemList<IRunCollectionModifier>)RunCollectionModifiers.Clone(new Cloner());
      return clone;
    }
    #endregion

    protected virtual void ReportProgress(double progress) {
      if (Progress != null) {
        Progress.ProgressValue = progress;
      }
    }

    protected virtual void FinishProgress() {
      if (Progress != null) {
        Progress.Finish();
      }
    }

    public void Pause() {
      cancellationTokenSource.Cancel();
    }

    public void Prepare() {
      executionStack.Clear();
      for (int i = RunCollectionModifiers.Count() - 1; i >= 0; i--) {
        executionStack.Push(RunCollectionModifiers[i]);
      }
      OnPrepared();
    }

    public void Start() {
      cancellationTokenSource = new CancellationTokenSource();

      Task task = Task.Factory.StartNew(RunModifiers, cancellationTokenSource.Token, cancellationTokenSource.Token);
      task.ContinueWith(t => {
        try {
          t.Wait();
        }
        catch (AggregateException ex) {
          try {
            ex.Flatten().Handle(x => x is OperationCanceledException);
          }
          catch (AggregateException remaining) {
            if (remaining.InnerExceptions.Count == 1) OnExceptionOccuted(remaining.InnerExceptions[0]);
            else OnExceptionOccuted(remaining);
          }
        }
        FinishProgress();
        cancellationTokenSource.Dispose();
        cancellationTokenSource = null;
        if (stopPending) executionStack.Clear();
        if (executionStack.Count == 0) OnStopped();
        else OnPaused();
      });
    }

    public void Stop() {
      if (ExecutionState == ExecutionState.Paused) {
        OnStopped();
      } else {
        stopPending = true;
        cancellationTokenSource.Cancel();
      }
    }

    public virtual void AddRunCollectionModifiers(IRunCollectionModifier modifier) {
      RunCollectionModifiers.Add(modifier);
    }

    protected virtual void RunModifiers(object state) {
      CancellationToken ct = (CancellationToken)state;
      OnStarted();
      var runs = RunCollection.ToList();

      IRunCollectionModifier next;
      while (executionStack.Count > 0) {
        next = executionStack.Pop();
        try {
          ct.ThrowIfCancellationRequested();
          next.Modify(runs);
          if (executionStack.Count > 0) {
            ReportProgress(((double)RunCollectionModifiers.Count) / executionStack.Count());
          } else {
            ReportProgress(1.0);
          }
        }
        catch (Exception ex) {
          executionStack.Push(next);
          if (ex is OperationCanceledException) throw ex;
          else throw new Exception("IRunCollectionModifier " + next + " threw an exception.", ex);
        }
        finally {
          RunCollection = new RunCollection(runs);
        }
      }
    }

    #region Events
    public event EventHandler Prepared;
    protected virtual void OnPrepared() {
      ExecutionState = ExecutionState.Prepared;
      EventHandler handler = Prepared;
      if (handler != null) handler(this, EventArgs.Empty);
    }
    public event EventHandler Started;
    protected virtual void OnStarted() {
      executionState = ExecutionState.Started;
      EventHandler handler = Started;
      if (handler != null) handler(this, EventArgs.Empty);
    }
    public event EventHandler Stopped;
    protected virtual void OnStopped() {
      executionState = ExecutionState.Stopped;
      EventHandler handler = Stopped;
      if (handler != null) handler(this, EventArgs.Empty);
    }
    public event EventHandler Paused;
    protected virtual void OnPaused() {
      executionState = ExecutionState.Paused;
      EventHandler handler = Paused;
      if (handler != null) handler(this, EventArgs.Empty);
    }
    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;
    protected virtual void OnExceptionOccuted(Exception e) {
      var eventArgs = new EventArgs<Exception>(e);
      Log.LogException(e);
      EventHandler<EventArgs<Exception>> handler = ExceptionOccurred;
      if (handler != null) handler(this, eventArgs);
    }
    public event EventHandler ExecutionTimeChanged;
    protected virtual void OnExecutionTimeChanged() {
      EventHandler handler = ExecutionTimeChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }
    public event EventHandler ExecutionStateChanged;
    protected virtual void OnExecutionStateChanged() {
      EventHandler handler = ExecutionStateChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }
    #endregion
  }
}