Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding.Views/3.3/HeuristicLab.Encodings.ScheduleEncoding.Views-3.3.csproj
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding.Views/3.3/HeuristicLab.Encodings.ScheduleEncoding.Views-3.3.csproj	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding.Views/3.3/HeuristicLab.Encodings.ScheduleEncoding.Views-3.3.csproj	(revision 13437)
@@ -191,4 +191,9 @@
       <Project>{3BD61258-31DA-4B09-89C0-4F71FEF5F05A}</Project>
       <Name>HeuristicLab.MainForm-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14ab8d24-25bc-400c-a846-4627aa945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
       <Private>False</Private>
     </ProjectReference>
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/GTAlgorithmUtils.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/GTAlgorithmUtils.cs	(revision 13437)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/GTAlgorithmUtils.cs	(revision 13437)
@@ -0,0 +1,80 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.ScheduleEncoding {
+  public static class GTAlgorithmUtils {
+
+    public static ItemList<Task> GetEarliestNotScheduledTasks(IEnumerable<Job> jobData) {
+      ItemList<Task> result = new ItemList<Task>();
+      foreach (Job j in jobData) {
+        foreach (Task t in j.Tasks) {
+          if (!t.IsScheduled) {
+            result.Add(t);
+            break;
+          }
+        }
+      }
+      return result;
+    }
+    public static Task GetTaskWithMinimalEC(IEnumerable<Task> earliestTasksList, Schedule schedule) {
+      double minEct = double.MaxValue;
+      Task result = null;
+      foreach (Task t in earliestTasksList) {
+        double ect = ComputeEarliestCompletionTime(t, schedule);
+        if (ect < minEct) {
+          result = t;
+          minEct = ect;
+        }
+      }
+      return result;
+    }
+    public static ItemList<Task> GetConflictSetForTask(Task conflictedTask, IEnumerable<Task> earliestTasksList, Schedule schedule) {
+      ItemList<Task> result = new ItemList<Task>();
+      double conflictedCompletionTime = ComputeEarliestCompletionTime(conflictedTask, schedule);
+      result.Add(conflictedTask);
+      foreach (Task t in earliestTasksList) {
+        if (t.ResourceNr == conflictedTask.ResourceNr) {
+          if (ComputeEarliestStartTime(t, schedule) < conflictedCompletionTime)
+            result.Add(t);
+        }
+      }
+      return result;
+    }
+
+    public static double ComputeEarliestStartTime(Task t, Schedule schedule) {
+      ScheduledTask previousTask = schedule.GetLastScheduledTaskForJobNr(t.JobNr);
+      Resource affectedResource = schedule.Resources[t.ResourceNr];
+      double lastMachineEndTime = affectedResource.TotalDuration;
+      double previousJobTaskEndTime = 0;
+      if (previousTask != null)
+        previousJobTaskEndTime = previousTask.EndTime;
+
+      return Math.Max(previousJobTaskEndTime, lastMachineEndTime);
+    }
+    private static double ComputeEarliestCompletionTime(Task t, Schedule schedule) {
+      return ComputeEarliestStartTime(t, schedule) + t.Duration;
+    }
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/HeuristicLab.Encodings.ScheduleEncoding-3.3.csproj
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/HeuristicLab.Encodings.ScheduleEncoding-3.3.csproj	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/HeuristicLab.Encodings.ScheduleEncoding-3.3.csproj	(revision 13437)
@@ -123,4 +123,5 @@
     <Compile Include="Interfaces\IScheduleCrossover.cs" />
     <Compile Include="Interfaces\ISchedule.cs" />
+    <Compile Include="Interfaces\IScheduleEncoding.cs" />
     <Compile Include="Interfaces\IScheduleManipulator.cs" />
     <Compile Include="Interfaces\IScheduleOperator.cs" />
@@ -129,4 +130,5 @@
     <Compile Include="JobSequenceMatrix\Crossovers\JSMOXCrossover.cs" />
     <Compile Include="JobSequenceMatrix\Crossovers\JSMSXXCrossover.cs" />
+    <Compile Include="JobSequenceMatrix\JobSequenceMatrixEncoding.cs" />
     <Compile Include="JobSequenceMatrix\JSMEncoding.cs" />
     <Compile Include="JobSequenceMatrix\JSMRandomCreator.cs" />
@@ -139,4 +141,5 @@
     <Compile Include="PermutationWithRepetition\Manipulators\PWRManipulator.cs" />
     <Compile Include="PermutationWithRepetition\Manipulators\PWRInsertionManipulator.cs" />
+    <Compile Include="PermutationWithRepetition\PermutationWithRepetitionEncoding.cs" />
     <Compile Include="PermutationWithRepetition\PWREncoding.cs" />
     <Compile Include="PermutationWithRepetition\PWRRandomCreator.cs" />
@@ -147,11 +150,14 @@
     <Compile Include="PriorityRulesVector\Manipulators\PRVManipulator.cs" />
     <Compile Include="PriorityRulesVector\Manipulators\PRVUniformOnePositionManipulator.cs" />
+    <Compile Include="PriorityRulesVector\PriorityRulesVectorEncoding.cs" />
     <Compile Include="PriorityRulesVector\PRVEncoding.cs" />
     <Compile Include="PriorityRulesVector\PRVRandomCreator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ScheduleEncoding.cs" />
     <Compile Include="ScheduleEncoding\Crossovers\DirectScheduleCrossover.cs" />
     <Compile Include="ScheduleEncoding\Crossovers\DirectScheduleGTCrossover.cs" />
-    <Compile Include="ScheduleEncoding\GTAlgorithmUtils.cs" />
-    <Compile Include="ScheduleEncoding\Job.cs" />
+    <Compile Include="GTAlgorithmUtils.cs" />
+    <Compile Include="Job.cs" />
+    <Compile Include="ScheduleEncoding\DirectScheduleEncoding.cs" />
     <Compile Include="ScheduleEncoding\Manipulators\DirectScheduleManipulator.cs" />
     <Compile Include="ScheduleEncoding\DirectScheduleRandomCreator.cs" />
@@ -161,5 +167,5 @@
     <Compile Include="ScheduleCreator.cs" />
     <Compile Include="ScheduleCrossover.cs" />
-    <Compile Include="ScheduleEncoding\Task.cs" />
+    <Compile Include="Task.cs" />
     <Compile Include="ScheduleManipulator.cs" />
   </ItemGroup>
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/IDirectScheduleOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/IDirectScheduleOperator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/IDirectScheduleOperator.cs	(revision 13437)
@@ -24,4 +24,5 @@
 namespace HeuristicLab.Encodings.ScheduleEncoding {
   public interface IDirectScheduleOperator : IOperator {
+    ILookupParameter<ItemList<Job>> JobDataParameter { get; }
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/ISchedule.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/ISchedule.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/ISchedule.cs	(revision 13437)
@@ -20,8 +20,8 @@
 #endregion
 
-using HeuristicLab.Core;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.ScheduleEncoding {
-  public interface ISchedule : IItem {
+  public interface ISchedule : ISolution {
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/IScheduleCreator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/IScheduleCreator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/IScheduleCreator.cs	(revision 13437)
@@ -21,9 +21,12 @@
 
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.ScheduleEncoding {
-  public interface IScheduleCreator : ISolutionCreator, IScheduleOperator {
+  public interface IScheduleCreator : ISolutionCreator<ISchedule>, IScheduleOperator {
     ILookupParameter<ISchedule> ScheduleParameter { get; }
+    IValueLookupParameter<IntValue> JobsParameter { get; }
+    IValueLookupParameter<IntValue> ResourcesParameter { get; }
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/IScheduleEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/IScheduleEncoding.cs	(revision 13437)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/IScheduleEncoding.cs	(revision 13437)
@@ -0,0 +1,39 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.ScheduleEncoding {
+  public interface IScheduleEncoding : IEncoding<ISchedule> {
+    IFixedValueParameter<ItemList<Job>> JobDataParameter { get; set; }
+    IFixedValueParameter<IntValue> JobsParameter { get; set; }
+    IFixedValueParameter<IntValue> ResourcesParameter { get; set; }
+
+    ItemList<Job> JobData { get; }
+    int Jobs { get; set; }
+    int Resources { get; set; }
+
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Job.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Job.cs	(revision 13437)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Job.cs	(revision 13437)
@@ -0,0 +1,160 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.ComponentModel;
+using System.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ScheduleEncoding {
+  [Item("Job", "Represents a composition of tasks that require processing in a scheduling problem.")]
+  [StorableClass]
+  public sealed class Job : Item, INotifyPropertyChanged {
+
+    [Storable(Name = "DueDate")]
+    private double dueDate;
+    public double DueDate {
+      get { return dueDate; }
+      set {
+        if (dueDate == value) return;
+        dueDate = value;
+        OnPropertyChanged("DueDate");
+        OnToStringChanged();
+      }
+    }
+
+    [Storable(Name = "Index")]
+    private int index;
+    public int Index {
+      get { return index; }
+      set {
+        if (index == value) return;
+        index = value;
+        OnPropertyChanged("Index");
+        OnToStringChanged();
+      }
+    }
+
+    [Storable(Name = "Tasks")]
+    private ItemList<Task> tasks;
+    public ItemList<Task> Tasks {
+      get { return tasks; }
+      private set {
+        tasks = value;
+        OnPropertyChanged("Tasks");
+      }
+    }
+
+    [StorableConstructor]
+    private Job(bool deserializing) : base(deserializing) { }
+    private Job(Job original, Cloner cloner)
+      : base(original, cloner) {
+      this.dueDate = original.DueDate;
+      this.index = original.Index;
+      this.tasks = cloner.Clone(original.Tasks);
+      RegisterEventHandlers();
+    }
+    public Job() : this(-1, double.MaxValue) { }
+    public Job(int index, double dueDate)
+      : base() {
+      this.dueDate = dueDate;
+      this.index = index;
+      this.tasks = new ItemList<Task>();
+      RegisterEventHandlers();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Job(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+    private void RegisterEventHandlers() {
+      Tasks.ItemsAdded += TasksOnItemsChanged;
+      Tasks.ItemsRemoved += TasksOnItemsRemoved;
+      Tasks.ItemsReplaced += TasksOnItemsChanged;
+      Tasks.CollectionReset += TasksOnItemsChanged;
+      foreach (var task in Tasks) {
+        task.PropertyChanged += TaskOnPropertyChanged;
+        task.ToStringChanged += TaskOnToStringChanged;
+      }
+    }
+
+    private void TasksOnItemsChanged(object sender, CollectionItemsChangedEventArgs<IndexedItem<Task>> e) {
+      foreach (var task in e.OldItems) {
+        task.Value.PropertyChanged -= TaskOnPropertyChanged;
+        task.Value.ToStringChanged -= TaskOnToStringChanged;
+      }
+      foreach (var task in e.Items) {
+        task.Value.PropertyChanged += TaskOnPropertyChanged;
+        task.Value.ToStringChanged += TaskOnToStringChanged;
+      }
+      OnTasksChanged();
+      OnToStringChanged();
+    }
+
+    private void TasksOnItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<Task>> e) {
+      foreach (var task in e.Items) {
+        task.Value.PropertyChanged -= TaskOnPropertyChanged;
+        task.Value.ToStringChanged -= TaskOnToStringChanged;
+      }
+      OnTasksChanged();
+      OnToStringChanged();
+    }
+
+    private void TaskOnPropertyChanged(object sender, EventArgs e) {
+      OnTasksChanged();
+    }
+
+    private void TaskOnToStringChanged(object sender, EventArgs e) {
+      OnToStringChanged();
+    }
+
+    public override string ToString() {
+      var sb = new StringBuilder();
+      sb.Append("Job#" + Index + " [ ");
+      foreach (Task t in Tasks) {
+        sb.Append(t + " ");
+      }
+      sb.Append("{" + DueDate + "} ");
+      sb.Append("]");
+      return sb.ToString();
+    }
+
+    public event EventHandler TasksChanged;
+    private void OnTasksChanged() {
+      var handler = TasksChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event PropertyChangedEventHandler PropertyChanged;
+    private void OnPropertyChanged(string propertyName) {
+      var handler = PropertyChanged;
+      if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
+    }
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMCrossover.cs	(revision 13437)
@@ -24,5 +24,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("JSMCrossover", "An operator which crosses two JSM representations.")]
   [StorableClass]
@@ -32,9 +32,6 @@
     protected JSMCrossover(bool deserializing) : base(deserializing) { }
     protected JSMCrossover(JSMCrossover original, Cloner cloner) : base(original, cloner) { }
-    public JSMCrossover()
-      : base() {
-      ParentsParameter.ActualName = "JobSequenceMatrix";
-      ChildParameter.ActualName = "JobSequenceMatrix";
-    }
+
+    public JSMCrossover() : base() { }
 
     public abstract JSMEncoding Cross(IRandom random, JSMEncoding parent1, JSMEncoding parent2);
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMJOXCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMJOXCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMJOXCrossover.cs	(revision 13437)
@@ -26,5 +26,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("JSMJobbasedOrderCrossover", "Represents a crossover operation swapping subsequences of the parents to generate offspring.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMOXCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMOXCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMOXCrossover.cs	(revision 13437)
@@ -24,5 +24,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("JSMOrderCrossover", "Represents a crossover operation swapping sequences of the parents to generate offspring.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMSXXCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMSXXCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMSXXCrossover.cs	(revision 13437)
@@ -25,5 +25,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("JSMSubsequenceExchangeCrossover", "Represents a crossover operation identifiying and exchanging equal subsequences of the parents to generate offspring.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/JSMEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/JSMEncoding.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/JSMEncoding.cs	(revision 13437)
@@ -20,5 +20,4 @@
 #endregion
 
-using System;
 using System.Text;
 using HeuristicLab.Common;
@@ -27,5 +26,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("JobSequenceMatrixEncoding", "Represents an encoding for a scheduling Problem using a list of job sequences to deliver scheduleinformation.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/JSMRandomCreator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/JSMRandomCreator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/JSMRandomCreator.cs	(revision 13437)
@@ -22,5 +22,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
@@ -28,5 +27,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("JobSequenceMatrixCreator", "Creator class used to create Job Sequence Matrix solutions for standard JobShop scheduling problems.")]
   [StorableClass]
@@ -35,10 +34,4 @@
     public ILookupParameter<IRandom> RandomParameter {
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public IValueLookupParameter<IntValue> JobsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Jobs"]; }
-    }
-    public IValueLookupParameter<IntValue> ResourcesParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Resources"]; }
     }
 
@@ -49,8 +42,4 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Jobs", "The number of jobs handled in this problem instance."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Resources", "The number of resources used in this problem instance."));
-
-      ScheduleParameter.ActualName = "JobSequenceMatrix";
     }
 
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/JobSequenceMatrixEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/JobSequenceMatrixEncoding.cs	(revision 13437)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/JobSequenceMatrixEncoding.cs	(revision 13437)
@@ -0,0 +1,68 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.ScheduleEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.Schedule {
+  [StorableClass]
+  public sealed class JobSequenceMatrixEncoding : ScheduleEncoding {
+    [StorableConstructor]
+    private JobSequenceMatrixEncoding(bool deserializing) : base(deserializing) { }
+    private JobSequenceMatrixEncoding(JobSequenceMatrixEncoding original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new JobSequenceMatrixEncoding(this, cloner);
+    }
+
+    public JobSequenceMatrixEncoding()
+      : base() {
+      SolutionCreator = new JSMRandomCreator();
+      DiscoverOperators();
+    }
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static JobSequenceMatrixEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+          typeof (IJSMOperator)
+      };
+    }
+    private void DiscoverOperators() {
+      var assembly = typeof(IDirectScheduleOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        AddOperator(@operator);
+    }
+    #endregion
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMManipulator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMManipulator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMManipulator.cs	(revision 13437)
@@ -25,5 +25,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("JSMManipulator", "An operator which manipulates a JSM representation.")]
   [StorableClass]
@@ -32,8 +32,5 @@
     protected JSMManipulator(bool deserializing) : base(deserializing) { }
     protected JSMManipulator(JSMManipulator original, Cloner cloner) : base(original, cloner) { }
-    public JSMManipulator()
-      : base() {
-      ScheduleParameter.ActualName = "JobSequenceMatrix";
-    }
+    public JSMManipulator() : base() { }
 
     protected abstract void Manipulate(IRandom random, ISchedule individual);
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMShiftChangeManipulator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMShiftChangeManipulator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMShiftChangeManipulator.cs	(revision 13437)
@@ -28,5 +28,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("JSMShiftChangeManipulator", "Represents a manipulation operation where the operations of a randomly determined job are shifted in one direction for all resources.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMSwapManipulator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMSwapManipulator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMSwapManipulator.cs	(revision 13437)
@@ -26,5 +26,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("JSMSwapManipulator", "Represents a manipulation operation swapping parts of the individual.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRCrossover.cs	(revision 13437)
@@ -24,5 +24,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PWRCrossover", "An operator which crosses two JSM representations.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRGOXCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRGOXCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRGOXCrossover.cs	(revision 13437)
@@ -27,5 +27,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PWRGeneralizationOrderCrossover", "Represents a crossover operation swapping sequences of the parents to generate offspring.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRPPXCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRPPXCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRPPXCrossover.cs	(revision 13437)
@@ -27,5 +27,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PWRPPXCrossover", "Represents a crossover operation swapping sequences of the parents to generate offspring.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Manipulators/PWRInsertionManipulator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Manipulators/PWRInsertionManipulator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Manipulators/PWRInsertionManipulator.cs	(revision 13437)
@@ -27,5 +27,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PWRInsertionManipulator", "Represents a manipulation operation inserting parts of the individual at another position.")]
   [StorableClass]
@@ -43,5 +43,5 @@
       int cutIndex = random.Next(individual.PermutationWithRepetition.Length);
       int insertIndex = random.Next(individual.PermutationWithRepetition.Length);
-      List<int> perm = ((IntegerVector)(individual.PermutationWithRepetition.Clone())).ToList<int>();
+      List<int> perm = ((IntegerVector)(individual.PermutationWithRepetition.Clone())).ToList();
       int aux = perm[cutIndex];
       if (cutIndex > insertIndex) {
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Manipulators/PWRManipulator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Manipulators/PWRManipulator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Manipulators/PWRManipulator.cs	(revision 13437)
@@ -25,5 +25,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PWRManipulator", "An operator which manipulates a PWR representation.")]
   [StorableClass]
@@ -33,8 +33,5 @@
     protected PWRManipulator(bool deserializing) : base(deserializing) { }
     protected PWRManipulator(PWRManipulator original, Cloner cloner) : base(original, cloner) { }
-    public PWRManipulator()
-      : base() {
-      ScheduleParameter.ActualName = "PermutationWithRepetition";
-    }
+    public PWRManipulator() : base() { }
 
     protected abstract void Manipulate(IRandom random, PWREncoding individual);
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/PWREncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/PWREncoding.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/PWREncoding.cs	(revision 13437)
@@ -26,5 +26,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PermutationWithRepetitionEncoding", "Represents a encoding for a standard JobShop Scheduling Problem.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/PWRRandomCreator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/PWRRandomCreator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/PWRRandomCreator.cs	(revision 13437)
@@ -22,10 +22,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PermutationWithRepetitionRandomCreator", "Creates PWR-individuals at random.")]
   [StorableClass]
@@ -34,10 +33,4 @@
     public ILookupParameter<IRandom> RandomParameter {
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public IValueLookupParameter<IntValue> JobsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Jobs"]; }
-    }
-    public IValueLookupParameter<IntValue> ResourcesParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Resources"]; }
     }
 
@@ -48,8 +41,4 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Jobs", "The number of jobs handled in this problem instance."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Resources", "The number of resources used in this problem instance."));
-
-      ScheduleParameter.ActualName = "PermutationWithRepetition";
     }
 
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/PermutationWithRepetitionEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/PermutationWithRepetitionEncoding.cs	(revision 13437)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/PermutationWithRepetitionEncoding.cs	(revision 13437)
@@ -0,0 +1,68 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.ScheduleEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.Schedule {
+  [StorableClass]
+  public sealed class PermutationWithRepetitionEncoding : ScheduleEncoding {
+    [StorableConstructor]
+    private PermutationWithRepetitionEncoding(bool deserializing) : base(deserializing) { }
+    private PermutationWithRepetitionEncoding(PermutationWithRepetitionEncoding original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PermutationWithRepetitionEncoding(this, cloner);
+    }
+
+    public PermutationWithRepetitionEncoding()
+      : base() {
+      SolutionCreator = new PWRRandomCreator();
+      DiscoverOperators();
+    }
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static PermutationWithRepetitionEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+          typeof (IPWROperator)
+      };
+    }
+    private void DiscoverOperators() {
+      var assembly = typeof(IDirectScheduleOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        AddOperator(@operator);
+    }
+    #endregion
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVCrossover.cs	(revision 13437)
@@ -24,5 +24,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PriorityRulesVector {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PRVCrossover", "An operator which crosses two PRV representations.")]
   [StorableClass]
@@ -32,9 +32,5 @@
     protected PRVCrossover(bool deserializing) : base(deserializing) { }
     protected PRVCrossover(PRVCrossover original, Cloner cloner) : base(original, cloner) { }
-    public PRVCrossover()
-      : base() {
-      ParentsParameter.ActualName = "PriorityRulesVector";
-      ChildParameter.ActualName = "PriorityRulesVector";
-    }
+    public PRVCrossover() : base() { }
 
     public abstract PRVEncoding Cross(IRandom random, PRVEncoding parent1, PRVEncoding parent2);
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVDiscreteCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVDiscreteCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVDiscreteCrossover.cs	(revision 13437)
@@ -25,5 +25,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PriorityRulesVector {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PRVDiscreteCrossover", "Represents a crossover operation swapping sequences of the parents to generate offspring.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVSinglePointCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVSinglePointCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVSinglePointCrossover.cs	(revision 13437)
@@ -25,5 +25,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PriorityRulesVector {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PRVSinglePointCrossover", "Represents a crossover operation swapping sequences of the parents to generate offspring.")]
   [StorableClass]
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Manipulators/PRVManipulator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Manipulators/PRVManipulator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Manipulators/PRVManipulator.cs	(revision 13437)
@@ -25,5 +25,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PriorityRulesVector {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PRVManipulator", "An operator which manipulates a PRV representation.")]
   [StorableClass]
@@ -32,8 +32,5 @@
     protected PRVManipulator(bool deserializing) : base(deserializing) { }
     protected PRVManipulator(PRVManipulator original, Cloner cloner) : base(original, cloner) { }
-    public PRVManipulator()
-      : base() {
-      ScheduleParameter.ActualName = "PriorityRulesVector";
-    }
+    public PRVManipulator() : base() { }
 
     protected abstract void Manipulate(IRandom random, PRVEncoding individual);
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Manipulators/PRVUniformOnePositionManipulator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Manipulators/PRVUniformOnePositionManipulator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Manipulators/PRVUniformOnePositionManipulator.cs	(revision 13437)
@@ -26,5 +26,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PriorityRulesVector {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PRVUniformOnePositionManipulator", "Represents a manipulation operation inserting parts of the individual at another position.")]
   [StorableClass]
@@ -41,5 +41,5 @@
 
     public static void Apply(IRandom random, PRVEncoding individual) {
-      UniformOnePositionManipulator.Apply(random, individual.PriorityRulesVector, new IntMatrix(new int[,] { { 0, individual.NrOfRules.Value } }));
+      UniformOnePositionManipulator.Apply(random, individual.PriorityRulesVector, new IntMatrix(new int[,] { { 0, individual.NrOfRules } }));
     }
 
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/PRVEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/PRVEncoding.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/PRVEncoding.cs	(revision 13437)
@@ -23,9 +23,8 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PriorityRulesVector {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PriorityRulesVectorEncoding", "Represents an encoding for a Scheduling Problem.")]
   [StorableClass]
@@ -35,10 +34,5 @@
 
     [Storable]
-    private IntValue nrOfRules;
-    public IntValue NrOfRules {
-      get {
-        return nrOfRules;
-      }
-    }
+    public int NrOfRules { get; private set; }
 
     [StorableConstructor]
@@ -46,20 +40,20 @@
     protected PRVEncoding(PRVEncoding original, Cloner cloner)
       : base(original, cloner) {
-      this.nrOfRules = cloner.Clone(original.NrOfRules);
+      this.NrOfRules = original.NrOfRules;
       this.PriorityRulesVector = cloner.Clone(original.PriorityRulesVector);
     }
     public PRVEncoding(int nrOfRules)
       : base() {
-      this.nrOfRules = new IntValue(nrOfRules);
+      this.NrOfRules = nrOfRules;
       this.PriorityRulesVector = new IntegerVector();
     }
-    public PRVEncoding(IntegerVector iv, IntValue nrOfRules)
+    public PRVEncoding(IntegerVector iv, int nrOfRules)
       : base() {
-      this.nrOfRules = (IntValue)nrOfRules.Clone();
+      this.NrOfRules = nrOfRules;
       this.PriorityRulesVector = (IntegerVector)iv.Clone();
     }
-    public PRVEncoding(int length, IRandom random, int min, int max, IntValue nrOfRules)
+    public PRVEncoding(int length, IRandom random, int min, int max, int nrOfRules)
       : base() {
-      this.nrOfRules = (IntValue)nrOfRules.Clone();
+      this.NrOfRules = nrOfRules;
       this.PriorityRulesVector = new IntegerVector(length, random, min, max);
     }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/PRVRandomCreator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/PRVRandomCreator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/PRVRandomCreator.cs	(revision 13437)
@@ -22,10 +22,9 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ScheduleEncoding.PriorityRulesVector {
+namespace HeuristicLab.Encodings.ScheduleEncoding {
   [Item("PriorityRulesRandomCreator", "Creator class used to create PRV encoding objects for scheduling problems.")]
   [StorableClass]
@@ -33,14 +32,8 @@
 
     [Storable]
-    public IntValue NrOfRules { get; set; }
+    public int NrOfRules { get; set; }
 
     public ILookupParameter<IRandom> RandomParameter {
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public IValueLookupParameter<IntValue> JobsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Jobs"]; }
-    }
-    public IValueLookupParameter<IntValue> ResourcesParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Resources"]; }
     }
 
@@ -49,21 +42,18 @@
     protected PRVRandomCreator(PRVRandomCreator original, Cloner cloner)
       : base(original, cloner) {
-      this.NrOfRules = cloner.Clone(original.NrOfRules);
+      this.NrOfRules = original.NrOfRules;
     }
-    public PRVRandomCreator()
-      : base() {
-      NrOfRules = new IntValue(10);
-      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Jobs", "The number of jobs handled in this problem instance."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Resources", "The number of resources used in this problem instance."));
-      ScheduleParameter.ActualName = "PriorityRulesVector";
-    }
-
     public override IDeepCloneable Clone(Cloner cloner) {
       return new PRVRandomCreator(this, cloner);
     }
 
-    public static PRVEncoding Apply(int jobs, int resources, IRandom random, IntValue nrOfRules) {
-      return new PRVEncoding(jobs * resources, random, 0, nrOfRules.Value, nrOfRules);
+    public PRVRandomCreator()
+      : base() {
+      NrOfRules = 10;
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
+    }
+
+    public static PRVEncoding Apply(int jobs, int resources, IRandom random, int nrOfRules) {
+      return new PRVEncoding(jobs * resources, random, 0, nrOfRules, nrOfRules);
     }
 
@@ -71,6 +61,4 @@
       return Apply(JobsParameter.ActualValue.Value, ResourcesParameter.ActualValue.Value, RandomParameter.ActualValue, NrOfRules);
     }
-
-
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/PriorityRulesVectorEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/PriorityRulesVectorEncoding.cs	(revision 13437)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/PriorityRulesVectorEncoding.cs	(revision 13437)
@@ -0,0 +1,68 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.ScheduleEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.Schedule {
+  [StorableClass]
+  public sealed class PriorityRulesVectorEncoding : ScheduleEncoding {
+    [StorableConstructor]
+    private PriorityRulesVectorEncoding(bool deserializing) : base(deserializing) { }
+    private PriorityRulesVectorEncoding(PriorityRulesVectorEncoding original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PriorityRulesVectorEncoding(this, cloner);
+    }
+
+    public PriorityRulesVectorEncoding()
+      : base() {
+      SolutionCreator = new PRVRandomCreator();
+      DiscoverOperators();
+    }
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static PriorityRulesVectorEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+          typeof (IPRVOperator)
+      };
+    }
+    private void DiscoverOperators() {
+      var assembly = typeof(IDirectScheduleOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        AddOperator(@operator);
+    }
+    #endregion
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleCreator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleCreator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleCreator.cs	(revision 13437)
@@ -22,4 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
@@ -34,4 +35,10 @@
       get { return (ILookupParameter<ISchedule>)Parameters["Schedule"]; }
     }
+    public IValueLookupParameter<IntValue> JobsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Jobs"]; }
+    }
+    public IValueLookupParameter<IntValue> ResourcesParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Resources"]; }
+    }
 
     [StorableConstructor]
@@ -40,5 +47,7 @@
     public ScheduleCreator()
       : base() {
-      Parameters.Add(new LookupParameter<ISchedule>("Schedule", "The new scheduling solutioncandidate."));
+      Parameters.Add(new LookupParameter<ISchedule>("Schedule", "The new scheduling solution candidate."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Jobs", "The number of jobs handled in this problem instance."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Resources", "The number of resources used in this problem instance."));
     }
 
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding.cs	(revision 13437)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding.cs	(revision 13437)
@@ -0,0 +1,159 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.ScheduleEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.Schedule {
+  [StorableClass]
+  public abstract class ScheduleEncoding : Encoding<ISchedule>, IScheduleEncoding {
+    #region Encoding Parameters
+    [Storable]
+    private IFixedValueParameter<ItemList<Job>> jobDataParameter;
+    public IFixedValueParameter<ItemList<Job>> JobDataParameter {
+      get { return jobDataParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("JobData parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("JobData parameter value must not be null.");
+        if (jobDataParameter == value) return;
+
+        if (jobDataParameter != null) Parameters.Remove(jobDataParameter);
+        jobDataParameter = value;
+        Parameters.Add(jobDataParameter);
+        OnJobDataParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IFixedValueParameter<IntValue> jobsParameter;
+    public IFixedValueParameter<IntValue> JobsParameter {
+      get { return jobsParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Jobs parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Jobs parameter value must not be null.");
+        if (jobsParameter == value) return;
+
+        if (jobsParameter != null) Parameters.Remove(jobsParameter);
+        jobsParameter = value;
+        Parameters.Add(jobsParameter);
+        OnJobsParameterChanged();
+      }
+    }
+    [Storable]
+    private IFixedValueParameter<IntValue> resourcesParameter;
+    public IFixedValueParameter<IntValue> ResourcesParameter {
+      get { return resourcesParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Resources parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Resources parameter value must not be null.");
+        if (resourcesParameter == value) return;
+
+        if (resourcesParameter != null) Parameters.Remove(resourcesParameter);
+        resourcesParameter = value;
+        Parameters.Add(resourcesParameter);
+        OnBoundsParameterChanged();
+      }
+    }
+    #endregion
+
+    public ItemList<Job> JobData {
+      get { return JobDataParameter.Value; }
+    }
+    public int Jobs {
+      get { return JobsParameter.Value.Value; }
+      set { JobsParameter.Value.Value = value; }
+    }
+    public int Resources {
+      get { return ResourcesParameter.Value.Value; }
+      set { ResourcesParameter.Value.Value = value; }
+    }
+
+
+    [StorableConstructor]
+    protected ScheduleEncoding(bool deserializing) : base(deserializing) { }
+    protected ScheduleEncoding(ScheduleEncoding original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected ScheduleEncoding() : this("Schedule") { }
+    protected ScheduleEncoding(string name) : this(name, Enumerable.Empty<Job>()) { }
+    protected ScheduleEncoding(string name, IEnumerable<Job> jobData)
+      : base(name) {
+      int jobs = jobData.Count();
+      int resources = jobData.SelectMany(j => j.Tasks).Select(t => t.ResourceNr).Distinct().Count();
+
+      jobDataParameter = new FixedValueParameter<ItemList<Job>>(Name + ".JobData", new ItemList<Job>(jobData));
+      jobsParameter = new FixedValueParameter<IntValue>(Name + ".Jobs", new IntValue(jobs));
+      resourcesParameter = new FixedValueParameter<IntValue>(Name + ".Resources", new IntValue(resources));
+
+      Parameters.Add(jobDataParameter);
+      Parameters.Add(jobsParameter);
+      Parameters.Add(resourcesParameter);
+    }
+
+    private void OnJobDataParameterChanged() {
+      ConfigureOperators(Operators);
+    }
+    private void OnJobsParameterChanged() {
+      ConfigureOperators(Operators);
+    }
+    private void OnBoundsParameterChanged() {
+      ConfigureOperators(Operators);
+    }
+
+
+    public override void ConfigureOperators(IEnumerable<IItem> operators) {
+      ConfigureCreators(operators.OfType<IScheduleCreator>());
+      ConfigureCrossovers(operators.OfType<IScheduleCrossover>());
+      ConfigureManipulators(operators.OfType<IScheduleManipulator>());
+    }
+
+    private void ConfigureCreators(IEnumerable<IScheduleCreator> creators) {
+      foreach (var creator in creators) {
+        creator.ScheduleParameter.ActualName = Name;
+        creator.JobsParameter.ActualName = JobsParameter.Name;
+        creator.ResourcesParameter.ActualName = ResourcesParameter.Name;
+      }
+    }
+
+    private void ConfigureCrossovers(IEnumerable<IScheduleCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ChildParameter.ActualName = Name;
+        crossover.ParentsParameter.ActualName = Name;
+      }
+    }
+
+    private void ConfigureManipulators(IEnumerable<IScheduleManipulator> manipulators) {
+      foreach (var manipulator in manipulators)
+        manipulator.ScheduleParameter.ActualName = Name;
+    }
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Crossovers/DirectScheduleCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Crossovers/DirectScheduleCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Crossovers/DirectScheduleCrossover.cs	(revision 13437)
@@ -29,4 +29,8 @@
   [StorableClass]
   public abstract class DirectScheduleCrossover : ScheduleCrossover, IDirectScheduleOperator {
+    public ILookupParameter<ItemList<Job>> JobDataParameter {
+      get { return (LookupParameter<ItemList<Job>>)Parameters["JobData"]; }
+    }
+
     [StorableConstructor]
     protected DirectScheduleCrossover(bool deserializing) : base(deserializing) { }
@@ -34,11 +38,5 @@
     public DirectScheduleCrossover()
       : base() {
-      ParentsParameter.ActualName = "Schedule";
-      ChildParameter.ActualName = "Schedule";
       Parameters.Add(new LookupParameter<ItemList<Job>>("JobData", "Job data taken from the JSSP - Instance."));
-    }
-
-    public ILookupParameter<ItemList<Job>> JobDataParameter {
-      get { return (LookupParameter<ItemList<Job>>)Parameters["JobData"]; }
     }
 
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Crossovers/DirectScheduleGTCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Crossovers/DirectScheduleGTCrossover.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Crossovers/DirectScheduleGTCrossover.cs	(revision 13437)
@@ -64,11 +64,9 @@
         Task minimal = GTAlgorithmUtils.GetTaskWithMinimalEC(earliestTasksList, child);
         int conflictedResourceNr = minimal.ResourceNr;
-        Resource conflictedResource = child.Resources[conflictedResourceNr];
 
         //STEP 2 - Compute a conflict set of all operations that can be scheduled on the conflicted resource
-        ItemList<Task> conflictSet = GTAlgorithmUtils.GetConflictSetForTask(minimal, earliestTasksList, jobData, child);
+        ItemList<Task> conflictSet = GTAlgorithmUtils.GetConflictSetForTask(minimal, earliestTasksList, child);
 
         //STEP 3 - Select a task from the conflict set
-        int progressOnResource = conflictedResource.Tasks.Count;
         Task selectedTask = null;
         if (random.NextDouble() < mutProp) {
@@ -77,5 +75,5 @@
         } else {
           //Crossover
-          selectedTask = SelectTaskFromConflictSet(conflictSet, ((random.Next(2) == 0) ? parent1 : parent2), conflictedResourceNr, progressOnResource);
+          selectedTask = SelectTaskFromConflictSet(conflictSet, ((random.Next(2) == 0) ? parent1 : parent2), conflictedResourceNr);
         }
 
@@ -92,5 +90,5 @@
     }
 
-    private static Task SelectTaskFromConflictSet(ItemList<Task> conflictSet, Schedule usedParent, int conflictedResourceNr, int progressOnResource) {
+    private static Task SelectTaskFromConflictSet(ItemList<Task> conflictSet, Schedule usedParent, int conflictedResourceNr) {
       //Apply Crossover
       foreach (ScheduledTask st in usedParent.Resources[conflictedResourceNr].Tasks) {
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/DirectScheduleEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/DirectScheduleEncoding.cs	(revision 13437)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/DirectScheduleEncoding.cs	(revision 13437)
@@ -0,0 +1,78 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.ScheduleEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.Schedule {
+  [StorableClass]
+  public sealed class DirectScheduleEncoding : ScheduleEncoding {
+    [StorableConstructor]
+    private DirectScheduleEncoding(bool deserializing) : base(deserializing) { }
+    private DirectScheduleEncoding(DirectScheduleEncoding original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DirectScheduleEncoding(this, cloner);
+    }
+
+    public DirectScheduleEncoding()
+      : base() {
+      SolutionCreator = new DirectScheduleRandomCreator();
+      DiscoverOperators();
+    }
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static DirectScheduleEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+          typeof (IDirectScheduleOperator)
+      };
+    }
+    private void DiscoverOperators() {
+      var assembly = typeof(IDirectScheduleOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        AddOperator(@operator);
+    }
+    #endregion
+
+    public override void ConfigureOperators(IEnumerable<IItem> operators) {
+      base.ConfigureOperators(operators);
+      ConfigureDirectScheduleOperators(operators.OfType<IDirectScheduleOperator>());
+    }
+
+    private void ConfigureDirectScheduleOperators(IEnumerable<IDirectScheduleOperator> operators) {
+      foreach (var @operator in operators)
+        @operator.JobDataParameter.ActualName = JobDataParameter.Name;
+    }
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/DirectScheduleRandomCreator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/DirectScheduleRandomCreator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/DirectScheduleRandomCreator.cs	(revision 13437)
@@ -23,6 +23,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -33,19 +31,12 @@
   [Item("DirectScheduleRandomCreator", "Creator class used to create schedule encoding objects.")]
   [StorableClass]
-  public class DirectScheduleRandomCreator : ScheduleCreator, IStochasticOperator {
+  public class DirectScheduleRandomCreator : ScheduleCreator, IStochasticOperator, IDirectScheduleOperator {
 
     public ILookupParameter<IRandom> RandomParameter {
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public IValueLookupParameter<IntValue> JobsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Jobs"]; }
-    }
-    public IValueLookupParameter<IntValue> ResourcesParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Resources"]; }
-    }
     public ILookupParameter<ItemList<Job>> JobDataParameter {
       get { return (LookupParameter<ItemList<Job>>)Parameters["JobData"]; }
     }
-
 
     [StorableConstructor]
@@ -60,8 +51,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Jobs", "The number of jobs handled in this problem instance."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Resources", "The number of resources used in this problem instance."));
       Parameters.Add(new LookupParameter<ItemList<Job>>("JobData", "Job data taken from the JSSP - Instance."));
-      ScheduleParameter.ActualName = "Schedule";
     }
 
@@ -89,5 +77,6 @@
           new PWREncoding(JobsParameter.ActualValue.Value, ResourcesParameter.ActualValue.Value, RandomParameter.ActualValue),
           jobData);
-      } catch {
+      }
+      catch {
         throw new Exception("ScheduleRandomCreator needs JobData parameter from a JSSP-Instance to create Schedule-Instances!");
       }
Index: anches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/GTAlgorithmUtils.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/GTAlgorithmUtils.cs	(revision 13436)
+++ 	(revision )
@@ -1,79 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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 HeuristicLab.Core;
-
-namespace HeuristicLab.Encodings.ScheduleEncoding {
-  public static class GTAlgorithmUtils {
-
-    public static ItemList<Task> GetEarliestNotScheduledTasks(ItemList<Job> jobData) {
-      ItemList<Task> result = new ItemList<Task>();
-      foreach (Job j in jobData) {
-        foreach (Task t in j.Tasks) {
-          if (!t.IsScheduled) {
-            result.Add(t);
-            break;
-          }
-        }
-      }
-      return result;
-    }
-    public static Task GetTaskWithMinimalEC(ItemList<Task> earliestTasksList, Schedule schedule) {
-      double minEct = double.MaxValue;
-      Task result = null;
-      foreach (Task t in earliestTasksList) {
-        double ect = ComputeEarliestCompletionTime(t, schedule);
-        if (ect < minEct) {
-          result = t;
-          minEct = ect;
-        }
-      }
-      return result;
-    }
-    public static ItemList<Task> GetConflictSetForTask(Task conflictedTask, ItemList<Task> earliestTasksList, ItemList<Job> jobData, Schedule schedule) {
-      ItemList<Task> result = new ItemList<Task>();
-      double conflictedCompletionTime = ComputeEarliestCompletionTime(conflictedTask, schedule);
-      result.Add(conflictedTask);
-      foreach (Task t in earliestTasksList) {
-        if (t.ResourceNr == conflictedTask.ResourceNr) {
-          if (ComputeEarliestStartTime(t, schedule) < conflictedCompletionTime)
-            result.Add(t);
-        }
-      }
-      return result;
-    }
-
-    public static double ComputeEarliestStartTime(Task t, Schedule schedule) {
-      ScheduledTask previousTask = schedule.GetLastScheduledTaskForJobNr(t.JobNr);
-      Resource affectedResource = schedule.Resources[t.ResourceNr];
-      double lastMachineEndTime = affectedResource.TotalDuration;
-      double previousJobTaskEndTime = 0;
-      if (previousTask != null)
-        previousJobTaskEndTime = previousTask.EndTime;
-
-      return Math.Max(previousJobTaskEndTime, lastMachineEndTime);
-    }
-    private static double ComputeEarliestCompletionTime(Task t, Schedule schedule) {
-      return ComputeEarliestStartTime(t, schedule) + t.Duration;
-    }
-  }
-}
Index: anches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Job.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Job.cs	(revision 13436)
+++ 	(revision )
@@ -1,160 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.ComponentModel;
-using System.Text;
-using HeuristicLab.Collections;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Encodings.ScheduleEncoding {
-  [Item("Job", "Represents a composition of tasks that require processing in a scheduling problem.")]
-  [StorableClass]
-  public sealed class Job : Item, INotifyPropertyChanged {
-
-    [Storable(Name = "DueDate")]
-    private double dueDate;
-    public double DueDate {
-      get { return dueDate; }
-      set {
-        if (dueDate == value) return;
-        dueDate = value;
-        OnPropertyChanged("DueDate");
-        OnToStringChanged();
-      }
-    }
-
-    [Storable(Name = "Index")]
-    private int index;
-    public int Index {
-      get { return index; }
-      set {
-        if (index == value) return;
-        index = value;
-        OnPropertyChanged("Index");
-        OnToStringChanged();
-      }
-    }
-
-    [Storable(Name = "Tasks")]
-    private ItemList<Task> tasks;
-    public ItemList<Task> Tasks {
-      get { return tasks; }
-      private set {
-        tasks = value;
-        OnPropertyChanged("Tasks");
-      }
-    }
-
-    [StorableConstructor]
-    private Job(bool deserializing) : base(deserializing) { }
-    private Job(Job original, Cloner cloner)
-      : base(original, cloner) {
-      this.dueDate = original.DueDate;
-      this.index = original.Index;
-      this.tasks = cloner.Clone(original.Tasks);
-      RegisterEventHandlers();
-    }
-    public Job() : this(-1, double.MaxValue) { }
-    public Job(int index, double dueDate)
-      : base() {
-      this.dueDate = dueDate;
-      this.index = index;
-      this.tasks = new ItemList<Task>();
-      RegisterEventHandlers();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Job(this, cloner);
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      RegisterEventHandlers();
-    }
-
-    private void RegisterEventHandlers() {
-      Tasks.ItemsAdded += TasksOnItemsChanged;
-      Tasks.ItemsRemoved += TasksOnItemsRemoved;
-      Tasks.ItemsReplaced += TasksOnItemsChanged;
-      Tasks.CollectionReset += TasksOnItemsChanged;
-      foreach (var task in Tasks) {
-        task.PropertyChanged += TaskOnPropertyChanged;
-        task.ToStringChanged += TaskOnToStringChanged;
-      }
-    }
-
-    private void TasksOnItemsChanged(object sender, CollectionItemsChangedEventArgs<IndexedItem<Task>> e) {
-      foreach (var task in e.OldItems) {
-        task.Value.PropertyChanged -= TaskOnPropertyChanged;
-        task.Value.ToStringChanged -= TaskOnToStringChanged;
-      }
-      foreach (var task in e.Items) {
-        task.Value.PropertyChanged += TaskOnPropertyChanged;
-        task.Value.ToStringChanged += TaskOnToStringChanged;
-      }
-      OnTasksChanged();
-      OnToStringChanged();
-    }
-
-    private void TasksOnItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<Task>> e) {
-      foreach (var task in e.Items) {
-        task.Value.PropertyChanged -= TaskOnPropertyChanged;
-        task.Value.ToStringChanged -= TaskOnToStringChanged;
-      }
-      OnTasksChanged();
-      OnToStringChanged();
-    }
-
-    private void TaskOnPropertyChanged(object sender, EventArgs e) {
-      OnTasksChanged();
-    }
-
-    private void TaskOnToStringChanged(object sender, EventArgs e) {
-      OnToStringChanged();
-    }
-
-    public override string ToString() {
-      var sb = new StringBuilder();
-      sb.Append("Job#" + Index + " [ ");
-      foreach (Task t in Tasks) {
-        sb.Append(t + " ");
-      }
-      sb.Append("{" + DueDate + "} ");
-      sb.Append("]");
-      return sb.ToString();
-    }
-
-    public event EventHandler TasksChanged;
-    private void OnTasksChanged() {
-      var handler = TasksChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    public event PropertyChangedEventHandler PropertyChanged;
-    private void OnPropertyChanged(string propertyName) {
-      var handler = PropertyChanged;
-      if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
-    }
-  }
-}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Manipulators/DirectScheduleManipulator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Manipulators/DirectScheduleManipulator.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Manipulators/DirectScheduleManipulator.cs	(revision 13437)
@@ -23,4 +23,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -29,11 +30,15 @@
   [StorableClass]
   public abstract class DirectScheduleManipulator : ScheduleManipulator, IDirectScheduleOperator {
+    public ILookupParameter<ItemList<Job>> JobDataParameter {
+      get { return (LookupParameter<ItemList<Job>>)Parameters["JobData"]; }
+    }
 
     [StorableConstructor]
     protected DirectScheduleManipulator(bool deserializing) : base(deserializing) { }
     protected DirectScheduleManipulator(DirectScheduleManipulator original, Cloner cloner) : base(original, cloner) { }
+
     public DirectScheduleManipulator()
       : base() {
-      ScheduleParameter.ActualName = "Schedule";
+      Parameters.Add(new LookupParameter<ItemList<Job>>("JobData", "Job data taken from the JSSP - Instance."));
     }
 
@@ -42,5 +47,5 @@
     public override IOperation InstrumentedApply() {
       var schedule = ScheduleParameter.ActualValue as Schedule;
-      if (schedule == null) throw new InvalidOperationException("ScheduleEncoding was not found or is not of type Schedule.");
+      if (schedule == null) throw new InvalidOperationException("Schedule was not found or is not of type Schedule.");
       Manipulate(RandomParameter.ActualValue, schedule);
       return base.InstrumentedApply();
Index: anches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Task.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Task.cs	(revision 13436)
+++ 	(revision )
@@ -1,131 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.ComponentModel;
-using System.Text;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Encodings.ScheduleEncoding {
-  [Item("Task", "Represents a task that has to be scheduled.")]
-  [StorableClass]
-  public class Task : Item, INotifyPropertyChanged {
-
-    [Storable(Name = "TaskNr")]
-    private int taskNr;
-    public int TaskNr {
-      get { return taskNr; }
-      set {
-        bool changed = taskNr != value;
-        taskNr = value;
-        if (changed) {
-          OnPropertyChanged("TaskNr");
-          OnToStringChanged();
-        }
-      }
-    }
-    [Storable(Name = "ResourceNr")]
-    private int resourceNr;
-    public int ResourceNr {
-      get { return resourceNr; }
-      set {
-        bool changed = resourceNr != value;
-        resourceNr = value;
-        if (changed) {
-          OnPropertyChanged("ResourceNr");
-          OnToStringChanged();
-        }
-      }
-    }
-
-    //this has to be exactly the number of the job which the task belongs to
-    //otherwise everything breaks and wrong results are calculated
-    [Storable(Name = "JobNr")]
-    private int jobNr;
-    public int JobNr {
-      get { return jobNr; }
-      set {
-        bool changed = jobNr != value;
-        jobNr = value;
-        if (changed) OnPropertyChanged("JobNr");
-      }
-    }
-
-    [Storable(Name = "Duration")]
-    private double duration;
-    public double Duration {
-      get { return duration; }
-      set {
-        bool changed = duration != value;
-        duration = value;
-        if (changed) OnPropertyChanged("Duration");
-      }
-    }
-
-    [Storable(Name = "IsScheduled")]
-    private bool isScheduled;
-    public bool IsScheduled {
-      get { return isScheduled; }
-      set {
-        bool changed = isScheduled != value;
-        isScheduled = value;
-        if (changed) OnPropertyChanged("IsScheduled");
-      }
-    }
-
-    [StorableConstructor]
-    protected Task(bool deserializing) : base(deserializing) { }
-    protected Task(Task original, Cloner cloner)
-      : base(original, cloner) {
-      this.resourceNr = original.ResourceNr;
-      this.jobNr = original.JobNr;
-      this.duration = original.Duration;
-      this.taskNr = original.TaskNr;
-      this.isScheduled = original.IsScheduled;
-    }
-    public Task() : this(-1, -1, -1, 0) { }
-    public Task(int taskNr, int resNr, int jobNr, double duration)
-      : base() {
-      this.duration = duration;
-      this.resourceNr = resNr;
-      this.jobNr = jobNr;
-      this.taskNr = taskNr;
-      this.isScheduled = false;
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Task(this, cloner);
-    }
-
-    public override string ToString() {
-      StringBuilder sb = new StringBuilder();
-      sb.Append("[" + TaskNr + "," + ResourceNr + "]");
-      return sb.ToString();
-    }
-
-    public event PropertyChangedEventHandler PropertyChanged;
-    protected virtual void OnPropertyChanged(string propertyName) {
-      var handler = PropertyChanged;
-      if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
-    }
-  }
-}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Task.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Task.cs	(revision 13437)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Task.cs	(revision 13437)
@@ -0,0 +1,131 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.ComponentModel;
+using System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ScheduleEncoding {
+  [Item("Task", "Represents a task that has to be scheduled.")]
+  [StorableClass]
+  public class Task : Item, INotifyPropertyChanged {
+
+    [Storable(Name = "TaskNr")]
+    private int taskNr;
+    public int TaskNr {
+      get { return taskNr; }
+      set {
+        bool changed = taskNr != value;
+        taskNr = value;
+        if (changed) {
+          OnPropertyChanged("TaskNr");
+          OnToStringChanged();
+        }
+      }
+    }
+    [Storable(Name = "ResourceNr")]
+    private int resourceNr;
+    public int ResourceNr {
+      get { return resourceNr; }
+      set {
+        bool changed = resourceNr != value;
+        resourceNr = value;
+        if (changed) {
+          OnPropertyChanged("ResourceNr");
+          OnToStringChanged();
+        }
+      }
+    }
+
+    //this has to be exactly the number of the job which the task belongs to
+    //otherwise everything breaks and wrong results are calculated
+    [Storable(Name = "JobNr")]
+    private int jobNr;
+    public int JobNr {
+      get { return jobNr; }
+      set {
+        bool changed = jobNr != value;
+        jobNr = value;
+        if (changed) OnPropertyChanged("JobNr");
+      }
+    }
+
+    [Storable(Name = "Duration")]
+    private double duration;
+    public double Duration {
+      get { return duration; }
+      set {
+        bool changed = duration != value;
+        duration = value;
+        if (changed) OnPropertyChanged("Duration");
+      }
+    }
+
+    [Storable(Name = "IsScheduled")]
+    private bool isScheduled;
+    public bool IsScheduled {
+      get { return isScheduled; }
+      set {
+        bool changed = isScheduled != value;
+        isScheduled = value;
+        if (changed) OnPropertyChanged("IsScheduled");
+      }
+    }
+
+    [StorableConstructor]
+    protected Task(bool deserializing) : base(deserializing) { }
+    protected Task(Task original, Cloner cloner)
+      : base(original, cloner) {
+      this.resourceNr = original.ResourceNr;
+      this.jobNr = original.JobNr;
+      this.duration = original.Duration;
+      this.taskNr = original.TaskNr;
+      this.isScheduled = original.IsScheduled;
+    }
+    public Task() : this(-1, -1, -1, 0) { }
+    public Task(int taskNr, int resNr, int jobNr, double duration)
+      : base() {
+      this.duration = duration;
+      this.resourceNr = resNr;
+      this.jobNr = jobNr;
+      this.taskNr = taskNr;
+      this.isScheduled = false;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Task(this, cloner);
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("[" + TaskNr + "," + ResourceNr + "]");
+      return sb.ToString();
+    }
+
+    public event PropertyChangedEventHandler PropertyChanged;
+    protected virtual void OnPropertyChanged(string propertyName) {
+      var handler = PropertyChanged;
+      if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
+    }
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 13437)
@@ -51,4 +51,8 @@
       }
       set {
+        if (double.IsNaN(value)) {
+          BestKnownQualityParameter.Value = null;
+          return;
+        }
         if (BestKnownQualityParameter.Value == null) BestKnownQualityParameter.Value = new DoubleValue(value);
         else BestKnownQualityParameter.Value.Value = value;
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecoder.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecoder.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecoder.cs	(revision 13437)
@@ -27,5 +27,4 @@
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Encodings.ScheduleEncoding;
-using HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -159,5 +158,5 @@
 
         //STEP 2 - Compute a conflict set of all operations that can be scheduled on the conflicted resource
-        ItemList<Task> conflictSet = GTAlgorithmUtils.GetConflictSetForTask(minimal, earliestTasksList, jobs, resultingSchedule);
+        ItemList<Task> conflictSet = GTAlgorithmUtils.GetConflictSetForTask(minimal, earliestTasksList, resultingSchedule);
 
         //STEP 3 - Select a task from the conflict set
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/Decoders/PRVDecoder.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/Decoders/PRVDecoder.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/Decoders/PRVDecoder.cs	(revision 13437)
@@ -24,5 +24,4 @@
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.ScheduleEncoding;
-using HeuristicLab.Encodings.ScheduleEncoding.PriorityRulesVector;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -225,9 +224,9 @@
 
         //STEP 2 - Compute a conflict set of all operations that can be scheduled on the machine the previously selected operation runs on
-        ItemList<Task> conflictSet = GTAlgorithmUtils.GetConflictSetForTask(minimal, earliestTasksList, jobs, resultingSchedule);
+        ItemList<Task> conflictSet = GTAlgorithmUtils.GetConflictSetForTask(minimal, earliestTasksList, resultingSchedule);
 
         //STEP 3 - Select an operation from the conflict set (various methods depending on how the algorithm should work..)
         //Task selectedTask = SelectTaskFromConflictSet(conflictSet, solution.PriorityRulesVector [currentDecisionIndex++], solution.NrOfRules.Value);
-        Task selectedTask = SelectTaskFromConflictSet(conflictSet, solution.PriorityRulesVector[minimal.JobNr], solution.NrOfRules.Value, resultingSchedule, jobs);
+        Task selectedTask = SelectTaskFromConflictSet(conflictSet, solution.PriorityRulesVector[minimal.JobNr], solution.NrOfRules, resultingSchedule, jobs);
 
         //STEP 4 - Adding the selected operation to the current schedule
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/Decoders/PWRDecoder.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/Decoders/PWRDecoder.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/Decoders/PWRDecoder.cs	(revision 13437)
@@ -24,5 +24,4 @@
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.ScheduleEncoding;
-using HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/HeuristicLab.Problems.Scheduling-3.3.csproj
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/HeuristicLab.Problems.Scheduling-3.3.csproj	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/HeuristicLab.Problems.Scheduling-3.3.csproj	(revision 13437)
@@ -127,11 +127,12 @@
     <Compile Include="Interfaces\IJSSPOperator.cs" />
     <Compile Include="Interfaces\IScheduleDecoder.cs" />
+    <Compile Include="Interfaces\IScheduleEvaluator.cs" />
     <Compile Include="Interfaces\ISchedulingEvaluator.cs" />
-    <Compile Include="Interfaces\IScheduleEvaluator.cs" />
+    <Compile Include="JobShopSchedulingProblem new.cs" />
     <Compile Include="JobShopSchedulingProblem.cs" />
     <Compile Include="Evaluators\SchedulingEvaluator.cs" />
-    <Compile Include="SchedulingProblem.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SchedulingProblem.cs" />
   </ItemGroup>
   <ItemGroup>
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/JobShopSchedulingProblem new.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/JobShopSchedulingProblem new.cs	(revision 13437)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/JobShopSchedulingProblem new.cs	(revision 13437)
@@ -0,0 +1,349 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Drawing;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.Schedule;
+using HeuristicLab.Encodings.ScheduleEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Problems.Scheduling {
+  [Item("Job Shop Scheduling Problem (JSSP) New", "Represents a standard Job Shop Scheduling Problem")]
+  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 120)]
+  [StorableClass]
+  public sealed class JobShopSchedulingProblemNew : SingleObjectiveProblem<IScheduleEncoding, ISchedule>, IProblemInstanceConsumer<JSSPData>, IProblemInstanceExporter<JSSPData>, IStorableContent {
+    #region Default Instance
+    private static readonly JSSPData DefaultInstance = new JSSPData() {
+      Jobs = 10,
+      Resources = 10,
+      BestKnownQuality = 930,
+      ProcessingTimes = new double[,] {
+          { 29, 78,  9, 36, 49, 11, 62, 56, 44, 21 },
+          { 43, 90, 75, 11, 69, 28, 46, 46, 72, 30 },
+          { 91, 85, 39, 74, 90, 10, 12, 89, 45, 33 },
+          { 81, 95, 71, 99,  9, 52, 85, 98, 22, 43 },
+          { 14,  6, 22, 61, 26, 69, 21, 49, 72, 53 },
+          { 84,  2, 52, 95, 48, 72, 47, 65,  6, 25 },
+          { 46, 37, 61, 13, 32, 21, 32, 89, 30, 55 },
+          { 31, 86, 46, 74, 32, 88, 19, 48, 36, 79 },
+          { 76, 69, 76, 51, 85, 11, 40, 89, 26, 74 },
+          { 85, 13, 61,  7, 64, 76, 47, 52, 90, 45 }
+        },
+      Demands = new int[,] {
+          { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
+          { 0, 2, 4, 9, 3, 1, 6, 5, 7, 8 },
+          { 1, 0, 3, 2, 8, 5, 7, 6, 9, 4 },
+          { 1, 2, 0, 4, 6, 8, 7, 3, 9, 5 },
+          { 2, 0, 1, 5, 3, 4, 8, 7, 9, 6 },
+          { 2, 1, 5, 3, 8, 9, 0, 6, 4, 7 },
+          { 1, 0, 3, 2, 6, 5, 9, 8, 7, 4 },
+          { 2, 0, 1, 5, 4, 6, 8, 9, 7, 3 },
+          { 0, 1, 3, 5, 2, 9, 6, 7, 4, 8 },
+          { 1, 0, 2, 6, 8, 9, 5, 3, 4, 7 }
+        }
+    };
+    #endregion
+
+    public override Image ItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Type; }
+    }
+
+    //TODO change to property of evaluator
+    public override bool Maximization {
+      get { return false; }
+    }
+
+
+    #region Parameter Properties
+    public IFixedValueParameter<ItemList<Job>> JobDataParameter {
+      get { return (IFixedValueParameter<ItemList<Job>>)Parameters["JobData"]; }
+    }
+    public OptionalValueParameter<Schedule> BestKnownSolutionParameter {
+      get { return (OptionalValueParameter<Schedule>)Parameters["BestKnownSolution"]; }
+    }
+
+    public IFixedValueParameter<IntValue> JobsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["Jobs"]; }
+    }
+    public IFixedValueParameter<IntValue> ResourcesParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["Resources"]; }
+    }
+    public IValueParameter<IScheduleEvaluator> ScheduleEvaluatorParameter {
+      get { return (IValueParameter<IScheduleEvaluator>)Parameters["ScheduleEvaluator"]; }
+    }
+    public OptionalValueParameter<IScheduleDecoder> ScheduleDecoderParameter {
+      get { return (OptionalValueParameter<IScheduleDecoder>)Parameters["ScheduleDecoder"]; }
+    }
+    #endregion
+
+    #region Properties
+    public ItemList<Job> JobData {
+      get { return JobDataParameter.Value; }
+    }
+    public Schedule BestKnownSolution {
+      get { return BestKnownSolutionParameter.Value; }
+      set { BestKnownSolutionParameter.Value = value; }
+    }
+    public int Jobs {
+      get { return JobsParameter.Value.Value; }
+      set { JobsParameter.Value.Value = value; }
+    }
+    public int Resources {
+      get { return ResourcesParameter.Value.Value; }
+      set { ResourcesParameter.Value.Value = value; }
+    }
+    public IScheduleEvaluator ScheduleEvaluator {
+      get { return ScheduleEvaluatorParameter.Value; }
+      set { ScheduleEvaluatorParameter.Value = value; }
+    }
+    public IScheduleDecoder ScheduleDecoder {
+      get { return ScheduleDecoderParameter.Value; }
+      set { ScheduleDecoderParameter.Value = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private JobShopSchedulingProblemNew(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+    private JobShopSchedulingProblemNew(JobShopSchedulingProblemNew original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new JobShopSchedulingProblemNew(this, cloner);
+    }
+
+    public JobShopSchedulingProblemNew()
+      : base() {
+      Parameters.Add(new FixedValueParameter<ItemList<Job>>("JobData", "Jobdata defining the precedence relationships and the duration of the tasks in this JSSP-Instance.", new ItemList<Job>()));
+      Parameters.Add(new OptionalValueParameter<Schedule>("BestKnownSolution", "The best known solution of this JSSP instance."));
+
+      Parameters.Add(new FixedValueParameter<IntValue>("Jobs", "The number of jobs used in this JSSP instance.", new IntValue()));
+      Parameters.Add(new FixedValueParameter<IntValue>("Resources", "The number of resources used in this JSSP instance.", new IntValue()));
+      Parameters.Add(new ValueParameter<IScheduleEvaluator>("ScheduleEvaluator", "The evaluator used to determine the quality of a solution.", new MakespanEvaluator()));
+      Parameters.Add(new OptionalValueParameter<IScheduleDecoder>("ScheduleDecoder", "The operator that decodes the representation and creates a schedule.", new JSMDecoder()));
+
+      Encoding = new DirectScheduleEncoding();
+
+      InitializeOperators();
+      Load(DefaultInstance);
+      RegisterEventHandlers();
+    }
+
+    public override double Evaluate(ISchedule solution, IRandom random) {
+      //TODO change to decoder
+      var schedule = (Schedule)solution;
+      return MakespanEvaluator.GetMakespan(schedule);
+    }
+
+    protected override void OnEncodingChanged() {
+      base.OnEncodingChanged();
+
+      Encoding.ResourcesParameter = ResourcesParameter;
+      Encoding.JobsParameter = JobsParameter;
+      Encoding.JobDataParameter = JobDataParameter;
+    }
+
+
+    private void RegisterEventHandlers() {
+      //ScheduleEvaluatorParameter.ValueChanged += ScheduleEvaluatorParameter_ValueChanged;
+      //ScheduleEvaluator.QualityParameter.ActualNameChanged += ScheduleEvaluator_QualityParameter_ActualNameChanged;
+      //SolutionCreator.ScheduleParameter.ActualNameChanged += SolutionCreator_SchedulingEncodingParameter_ActualNameChanged;
+      //ScheduleDecoderParameter.ValueChanged += ScheduleDecoderParameter_ValueChanged;
+      //if (ScheduleDecoder != null) ScheduleDecoder.ScheduleParameter.ActualNameChanged += ScheduleDecoder_ScheduleParameter_ActualNameChanged;
+    }
+
+    #region Events
+    protected override void OnSolutionCreatorChanged() {
+      //SolutionCreator.ScheduleParameter.ActualNameChanged += SolutionCreator_SchedulingEncodingParameter_ActualNameChanged;
+      //InitializeOperators();
+    }
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      ParameterizeOperators();
+    }
+    private void ScheduleEvaluatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      ScheduleEvaluator.QualityParameter.ActualNameChanged += ScheduleEvaluator_QualityParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void ScheduleEvaluator_QualityParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+
+    private void SolutionCreator_SchedulingEncodingParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    private void ScheduleDecoderParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      if (ScheduleDecoder != null) ScheduleDecoder.ScheduleParameter.ActualNameChanged += ScheduleDecoder_ScheduleParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void ScheduleDecoder_ScheduleParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    #endregion
+
+    #region Helpers
+    private void InitializeOperators() {
+      Operators.Clear();
+      ApplyEncoding();
+      Operators.Add(new BestSchedulingSolutionAnalyzer());
+      ParameterizeOperators();
+    }
+
+    private void ApplyEncoding() {
+      if (SolutionCreator.GetType() == typeof(JSMRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IJSMOperator>());
+        ScheduleDecoder = new JSMDecoder();
+      } else if (SolutionCreator.GetType() == typeof(PRVRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IPRVOperator>());
+        ScheduleDecoder = new PRVDecoder();
+      } else if (SolutionCreator.GetType() == typeof(PWRRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IPWROperator>());
+        ScheduleDecoder = new PWRDecoder();
+      } else if (SolutionCreator.GetType() == typeof(DirectScheduleRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IDirectScheduleOperator>());
+        ScheduleDecoder = null;
+      }
+    }
+
+    private void ParameterizeOperators() {
+      //Evaluator.ScheduleDecoderParameter.ActualName = ScheduleDecoderParameter.Name;
+      //Evaluator.ScheduleDecoderParameter.Hidden = true;
+      //Evaluator.ScheduleEvaluatorParameter.ActualName = ScheduleEvaluatorParameter.Name;
+      //Evaluator.ScheduleEvaluatorParameter.Hidden = true;
+      //Evaluator.QualityParameter.ActualName = ScheduleEvaluator.QualityParameter.ActualName;
+      //Evaluator.QualityParameter.Hidden = true;
+
+      //if (ScheduleDecoder != null)
+      //  ScheduleDecoder.ScheduleEncodingParameter.ActualName = SolutionCreator.ScheduleParameter.ActualName;
+
+      //if (ScheduleDecoder != null) {
+      //  ScheduleEvaluator.ScheduleParameter.ActualName = ScheduleDecoder.ScheduleParameter.ActualName;
+      //  ScheduleEvaluator.ScheduleParameter.Hidden = true;
+      //} else if (SolutionCreator is DirectScheduleRandomCreator) {
+      //  var directEvaluator = (DirectScheduleRandomCreator)SolutionCreator;
+      //  ScheduleEvaluator.ScheduleParameter.ActualName = directEvaluator.ScheduleParameter.ActualName;
+      //  ScheduleEvaluator.ScheduleParameter.Hidden = true;
+      //} else {
+      //  ScheduleEvaluator.ScheduleParameter.ActualName = ScheduleEvaluator.ScheduleParameter.Name;
+      //  ScheduleEvaluator.ScheduleParameter.Hidden = false;
+      //}
+
+      //foreach (var op in Operators.OfType<IScheduleManipulator>()) {
+      //  op.ScheduleParameter.ActualName = SolutionCreator.ScheduleParameter.ActualName;
+      //  op.ScheduleParameter.Hidden = true;
+      //}
+
+      //foreach (var op in Operators.OfType<IScheduleCrossover>()) {
+      //  op.ChildParameter.ActualName = SolutionCreator.ScheduleParameter.ActualName;
+      //  op.ChildParameter.Hidden = true;
+      //  op.ParentsParameter.ActualName = SolutionCreator.ScheduleParameter.ActualName;
+      //  op.ParentsParameter.Hidden = true;
+      //}
+
+      //foreach (var op in Operators.OfType<BestSchedulingSolutionAnalyzer>()) {
+      //  op.QualityParameter.ActualName = ScheduleEvaluator.QualityParameter.ActualName;
+      //  if (ScheduleDecoder != null) {
+      //    op.ScheduleParameter.ActualName = ScheduleDecoder.ScheduleParameter.ActualName;
+      //    op.ScheduleParameter.Hidden = true;
+      //  } else if (SolutionCreator is DirectScheduleRandomCreator) {
+      //    op.ScheduleParameter.ActualName = ((DirectScheduleRandomCreator)SolutionCreator).ScheduleParameter.ActualName;
+      //    op.ScheduleParameter.Hidden = true;
+      //  } else {
+      //    op.ScheduleParameter.ActualName = op.ScheduleParameter.Name;
+      //    op.ScheduleParameter.Hidden = false;
+      //  }
+      //}
+    }
+    #endregion
+
+    #region Problem Instance Handling
+    public void Load(JSSPData data) {
+      var jobData = new ItemList<Job>(data.Jobs);
+      for (int j = 0; j < data.Jobs; j++) {
+        var job = new Job(j, data.DueDates != null ? data.DueDates[j] : double.MaxValue);
+        for (int t = 0; t < data.Resources; t++) {
+          job.Tasks.Add(new Task(t, data.Demands[j, t], j, data.ProcessingTimes[j, t]));
+        }
+        jobData.Add(job);
+      }
+
+      BestKnownQuality = data.BestKnownQuality ?? double.NaN;
+      if (data.BestKnownSchedule != null) {
+        var enc = new JSMEncoding();
+        enc.JobSequenceMatrix = new ItemList<Permutation>(data.Resources);
+        for (int i = 0; i < data.Resources; i++) {
+          enc.JobSequenceMatrix[i] = new Permutation(PermutationTypes.Absolute, new int[data.Jobs]);
+          for (int j = 0; j < data.Jobs; j++) {
+            enc.JobSequenceMatrix[i][j] = data.BestKnownSchedule[i, j];
+          }
+        }
+        BestKnownSolution = new JSMDecoder().CreateScheduleFromEncoding(enc, jobData);
+        if (ScheduleEvaluator is MeanTardinessEvaluator)
+          BestKnownQuality = MeanTardinessEvaluator.GetMeanTardiness(BestKnownSolution, jobData);
+        else if (ScheduleEvaluator is MakespanEvaluator)
+          BestKnownQuality = MakespanEvaluator.GetMakespan(BestKnownSolution);
+      }
+
+      JobData.Clear();
+      JobData.AddRange(jobData);
+      Jobs = data.Jobs;
+      Resources = data.Resources;
+    }
+
+    public JSSPData Export() {
+      var result = new JSSPData {
+        Name = Name,
+        Description = Description,
+        Jobs = Jobs,
+        Resources = Resources,
+        ProcessingTimes = new double[Jobs, Resources],
+        Demands = new int[Jobs, Resources],
+        DueDates = new double[Jobs]
+      };
+
+      foreach (var job in JobData) {
+        var counter = 0;
+        result.DueDates[job.Index] = job.DueDate;
+        foreach (var task in job.Tasks) {
+          result.ProcessingTimes[task.JobNr, counter] = task.Duration;
+          result.Demands[task.JobNr, counter] = task.ResourceNr;
+          counter++;
+        }
+      }
+      return result;
+    }
+    #endregion
+
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/JobShopSchedulingProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/JobShopSchedulingProblem.cs	(revision 13436)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Scheduling/3.3/JobShopSchedulingProblem.cs	(revision 13437)
@@ -28,7 +28,4 @@
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Encodings.ScheduleEncoding;
-using HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix;
-using HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition;
-using HeuristicLab.Encodings.ScheduleEncoding.PriorityRulesVector;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
