source: branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.HiveEngine/3.4/EngineJob.cs @ 5958

using System;
using System.Collections.Generic;
using System.Drawing;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Hive;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.HiveEngine {
  [StorableClass]
  public class EngineJob : AbstractJob {
    [Storable]
    private IEngine engine;

    [Storable]
    protected IOperation initialOperation;
    public IOperation InitialOperation {
      get { return initialOperation; }
      set { initialOperation = value; }
    }

    public override TimeSpan ExecutionTime {
      get { return engine.ExecutionTime; }
    }

    public override ExecutionState ExecutionState {
      get { return engine.ExecutionState; }
    }

    #region constructors and cloning
    public EngineJob() { }
    public EngineJob(IOperation initialOperation, IEngine engine) {
      this.initialOperation = initialOperation;
      this.engine = engine;
      this.engine.Prepare(initialOperation);
      RegisterEngineEvents();
    }

    [StorableConstructor]
    protected EngineJob(bool deserializing) : base(deserializing) { }
    protected EngineJob(EngineJob original, Cloner cloner)
      : base(original, cloner) {
      this.engine = cloner.Clone(original.engine);
      RegisterEngineEvents();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new EngineJob(this, cloner);
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      RegisterEngineEvents();
    }
    #endregion

    public override bool IsParallelizable {
      get { return false; }
    }

    public override void Prepare() { }

    public override void Start() {
      engine.Start();
    }
    
    public override void Pause() {
      throw new NotImplementedException();
    }

    public override void Stop() {
      engine.Stop();
    }
    
    public override void Resume(IEnumerable<IJob> childJobs) {
      throw new NotImplementedException();
    }

    private void RegisterEngineEvents() {
      engine.Stopped += new EventHandler(engine_Stopped);
      engine.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(engine_ExceptionOccurred);
    }

    void engine_ExceptionOccurred(object sender, EventArgs<Exception> e) {
      OnJobFailed(e);
    }

    void engine_Stopped(object sender, EventArgs e) {
      OnJobStopped();
    }

    public override bool CanChangeDescription {
      get { return false; }
    }

    public override bool CanChangeName {
      get { return false; }
    }

    public override string Description {
      get { return string.Empty; }
      set { throw new NotSupportedException(); }
    }

    public override string Name {
      get { return engine.ToString(); }
      set { throw new NotSupportedException(); }
    }

    public override string ItemDescription {
      get { return Description; }
    }

    public override Image ItemImage {
      get { return HeuristicLab.Common.Resources.VSImageLibrary.Operator; }
    }
    
    public override string ItemName {
      get { return "EngineJob"; }
    }

    public override Version ItemVersion {
      get { return null; }
    }
  }
}