Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Analyzers/BestSchedulingSolutionAnalyzer.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Analyzers/BestSchedulingSolutionAnalyzer.cs	(revision 6292)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Analyzers/BestSchedulingSolutionAnalyzer.cs	(revision 6293)
@@ -30,5 +30,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Data;
-using HeuristicLab.Problems.Scheduling.Encodings;
+using HeuristicLab.Encodings.SchedulingEncoding;
 
 namespace HeuristicLab.Problems.Scheduling.Analyzers {
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Analyzers/SchedulingAnalyzer.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Analyzers/SchedulingAnalyzer.cs	(revision 6292)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Analyzers/SchedulingAnalyzer.cs	(revision 6293)
@@ -31,4 +31,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Common;
+using HeuristicLab.Encodings.SchedulingEncoding;
 
 namespace HeuristicLab.Problems.Scheduling.Analyzers {
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/GTAlgorithmUtils.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/GTAlgorithmUtils.cs	(revision 6293)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/GTAlgorithmUtils.cs	(revision 6293)
@@ -0,0 +1,62 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Encodings.SchedulingEncoding;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.Scheduling.Decoders {
+  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.Value) {
+            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.Value == conflictedTask.ResourceNr.Value) {
+          if (ComputeEarliestStartTime(t, schedule) < conflictedCompletionTime)
+            result.Add(t);
+        }
+      }
+      return result;
+    }
+    
+    public static double ComputeEarliestStartTime(Task t, Schedule schedule) {
+      ScheduledTask previousTask = schedule.GetLastScheduledTaskForJobNr (t.JobNr.Value);
+      Resource affectedResource = schedule.Resources[t.ResourceNr.Value];
+      double lastMachineEndTime = affectedResource.TotalDuration.Value;
+      double previousJobTaskEndTime = 0;
+      if (previousTask != null)
+        previousJobTaskEndTime = previousTask.EndTime.Value;
+
+      return Math.Max(previousJobTaskEndTime, lastMachineEndTime);
+    }
+    public static double ComputeEarliestCompletionTime(Task t, Schedule schedule) {
+      return ComputeEarliestStartTime(t, schedule) + t.Duration.Value;
+    }
+  }
+}
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecoder.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecoder.cs	(revision 6293)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecoder.cs	(revision 6293)
@@ -0,0 +1,190 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Encodings.SchedulingEncoding.JobSequenceMatrix;
+using HeuristicLab.Encodings.SchedulingEncoding;
+using HeuristicLab.Problems.Scheduling.Interfaces;
+
+namespace HeuristicLab.Problems.Scheduling.Decoders {
+  [Item("Job Sequencing Matrix Decoder", "Applies the GifflerThompson algorithm to create an active schedule from a JobSequencing Matrix.")]
+  [StorableClass]
+  public class JSMDecoder : SchedulingDecoder<JSMEncoding>, IStochasticOperator, IJSSPOperator {
+    [StorableConstructor]
+    protected JSMDecoder(bool deserializing) : base(deserializing) { }
+    protected JSMDecoder(JSMDecoder original, Cloner cloner)
+      : base(original, cloner) {
+        this.resultingSchedule = cloner.Clone(original.resultingSchedule);
+        this.jobs = cloner.Clone(original.jobs);
+        this.decodingErrorPolicy = original.decodingErrorPolicy;
+        this.forcingStrategy = original.forcingStrategy;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new JSMDecoder(this, cloner);
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemList<Job>> JobDataParameter {
+      get { return (LookupParameter<ItemList<Job>>)Parameters["JobData"]; }
+    }
+
+    #region Private Members
+    [Storable]
+    private Schedule resultingSchedule;
+
+    [Storable]
+    private ItemList<Job> jobs;
+
+    [Storable]
+    private JSMDecodingErrorPolicyTypes decodingErrorPolicy = JSMDecodingErrorPolicyTypes.GuidedPolicy;
+
+    [Storable]
+    private JSMForcingStrategyTypes forcingStrategy = JSMForcingStrategyTypes.ShiftForcing; 
+    #endregion
+
+    public JSMDecoder()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<ItemList<Job>>("JobData", "Job data taken from the JSSP - Instance."));
+    }
+
+    
+    private Task SelectTaskFromConflictSet(int conflictedResourceNr, int progressOnConflictedResource, ItemList<Task> conflictSet, ItemList<Permutation> jsm) {
+      if (conflictSet.Count == 1)
+        return conflictSet[0];
+      
+      //get solutionCandidate from jobSequencingMatrix
+      int solutionCandidateJobNr = jsm[conflictedResourceNr][progressOnConflictedResource];
+
+      //scan conflictSet for given solutionCandidate, and return if found
+      foreach (Task t in conflictSet) {
+        if (t.JobNr.Value == solutionCandidateJobNr)
+          return t;
+      }
+
+      //if solutionCandidate wasn't found in conflictSet apply DecodingErrorPolicy and ForcingPolicy
+      Task result = ApplyDecodingErrorPolicy(conflictSet, jsm[conflictedResourceNr], progressOnConflictedResource);
+      int newResolutionIndex = 0;
+
+      while (newResolutionIndex < jsm[conflictedResourceNr].Length && jsm[conflictedResourceNr][newResolutionIndex] != result.JobNr.Value)
+        newResolutionIndex++;
+      ApplyForcingStrategy(jsm, conflictedResourceNr, newResolutionIndex, progressOnConflictedResource, result.JobNr.Value);
+
+      return result;
+    }
+    private Task ApplyDecodingErrorPolicy(ItemList<Task> conflictSet, Permutation resource, int progress) {
+      if (decodingErrorPolicy == JSMDecodingErrorPolicyTypes.RandomPolicy) { 
+        //Random
+        return conflictSet[RandomParameter.ActualValue.Next(conflictSet.Count - 1)];
+      } else {
+        //Guided
+        for (int i = progress; i < resource.Length; i++) {
+          int j = 0;
+          while (j < conflictSet.Count && conflictSet[j].JobNr.Value != resource[i])
+            j++;
+
+          if (j < conflictSet.Count)
+            return (conflictSet[j]);
+        }
+        return conflictSet[RandomParameter.ActualValue.Next(conflictSet.Count - 1)];
+      }    
+    }
+    private void ApplyForcingStrategy(ItemList<Permutation> jsm, int conflictedResource, int newResolutionIndex, int progressOnResource, int newResolution) {
+      if (forcingStrategy == JSMForcingStrategyTypes.SwapForcing) {
+        //SwapForcing
+        jsm[conflictedResource][newResolutionIndex] = jsm[conflictedResource][progressOnResource];
+        jsm[conflictedResource][progressOnResource] = newResolution;
+      } else {
+        //ShiftForcing
+        List<int> asList = jsm[conflictedResource].ToList<int>();
+        if (newResolutionIndex > progressOnResource) {
+          asList.RemoveAt(newResolutionIndex);
+          asList.Insert(progressOnResource, newResolution);
+        } else {
+          asList.Insert(progressOnResource, newResolution); 
+          asList.RemoveAt(newResolutionIndex);
+        }
+        jsm[conflictedResource] = new Permutation (PermutationTypes.Absolute, asList.ToArray<int>());
+      } 
+    }
+
+    public Schedule CreateScheduleFromEncoding(JSMEncoding solution, ItemList<Job> jobData) {
+      ItemList<Permutation> jobSequenceMatrix = solution.JobSequenceMatrix;
+
+      jobs = (ItemList<Job>)jobData.Clone();
+      resultingSchedule = new Schedule(new IntValue(jobs[0].Tasks.Count));
+
+      //Reset scheduled tasks in result
+      foreach (Job j in jobs) {
+        foreach (Task t in j.Tasks) {
+          t.IsScheduled.Value = false;
+        }
+      }
+
+      //GT-Algorithm
+      //STEP 0 - Compute a list of "earliest operations"
+      ItemList<Task> earliestTasksList = GTAlgorithmUtils.GetEarliestNotScheduledTasks(jobs);
+      while (earliestTasksList.Count > 0) {
+        //STEP 1 - Get earliest not scheduled operation with minimal earliest completing time
+        Task minimal = GTAlgorithmUtils.GetTaskWithMinimalEC(earliestTasksList, resultingSchedule);
+        int conflictedResourceNr = minimal.ResourceNr.Value;
+        Resource conflictedResource = resultingSchedule.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, jobs, resultingSchedule);
+
+        //STEP 3 - Select a task from the conflict set
+        int progressOnResource = conflictedResource.Tasks.Count;
+        Task selectedTask = SelectTaskFromConflictSet(conflictedResourceNr, progressOnResource, conflictSet, jobSequenceMatrix);
+
+        //STEP 4 - Add the selected task to the current schedule 
+        selectedTask.IsScheduled.Value = true;
+        double startTime = GTAlgorithmUtils.ComputeEarliestStartTime(selectedTask, resultingSchedule);
+        resultingSchedule.ScheduleTask(selectedTask.ResourceNr.Value, startTime, selectedTask.Duration.Value, selectedTask.JobNr.Value);
+
+        //STEP 5 - Back to STEP 1
+        earliestTasksList = GTAlgorithmUtils.GetEarliestNotScheduledTasks(jobs);
+      }
+
+      return resultingSchedule;
+    }
+
+    public override Schedule CreateScheduleFromEncoding(JSMEncoding solution) {
+      return CreateScheduleFromEncoding(solution, JobDataParameter.ActualValue);
+    }
+
+    public override IOperation Apply() {
+      return base.Apply();
+    }    
+  }
+}
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecodingErrorPolicyTypes.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecodingErrorPolicyTypes.cs	(revision 6293)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecodingErrorPolicyTypes.cs	(revision 6293)
@@ -0,0 +1,11 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace HeuristicLab.Problems.Scheduling.Decoders {
+  public enum JSMDecodingErrorPolicyTypes {
+    RandomPolicy,
+    GuidedPolicy
+  }
+}
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMForcingStrategyTypes.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMForcingStrategyTypes.cs	(revision 6293)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMForcingStrategyTypes.cs	(revision 6293)
@@ -0,0 +1,11 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace HeuristicLab.Problems.Scheduling.Decoders {
+  public enum JSMForcingStrategyTypes {
+    ShiftForcing,
+    SwapForcing
+  }
+}
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/PRVDecoder.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/PRVDecoder.cs	(revision 6293)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/PRVDecoder.cs	(revision 6293)
@@ -0,0 +1,295 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.Scheduling.Interfaces;
+using HeuristicLab.Encodings.SchedulingEncoding.PriorityRulesVector;
+using HeuristicLab.Encodings.SchedulingEncoding;
+
+namespace HeuristicLab.Problems.Scheduling.Decoders {
+  [Item("Job Sequencing Matrix Decoder", "Applies the GifflerThompson algorithm to create an active schedule from a JobSequencing Matrix.")]
+  [StorableClass]
+  public class PRVDecoder : SchedulingDecoder<PRVEncoding>, IStochasticOperator, IJSSPOperator {
+    [StorableConstructor]
+    protected PRVDecoder(bool deserializing) : base(deserializing) { }
+    protected PRVDecoder(PRVDecoder original, Cloner cloner)
+      : base(original, cloner) {
+        this.resultingSchedule = cloner.Clone(original.resultingSchedule);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PRVDecoder(this, cloner);
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemList<Job>> JobDataParameter {
+      get { return (LookupParameter<ItemList<Job>>)Parameters["JobData"]; }
+    }
+
+    #region Private Members
+    [Storable]
+    private Schedule resultingSchedule;
+
+    [Storable]
+    private ItemList<Job> jobs;
+    #endregion
+
+    #region Priority Rules
+    //smallest number of remaining tasks
+    private Task FILORule(ItemList<Task> tasks) {
+      Task currentResult = tasks[tasks.Count-1];
+      return currentResult;
+    }
+
+    //earliest start time
+    private Task ESTRule(ItemList<Task> tasks) {
+      Task currentResult = RandomRule(tasks);
+      double currentEST = double.MaxValue;
+      foreach (Task t in tasks) {
+        double est = GTAlgorithmUtils.ComputeEarliestStartTime(t, resultingSchedule);
+        if (est < currentEST) {
+          currentEST = est;
+          currentResult = t;
+        }
+      }
+      return currentResult;
+    }
+   
+    //shortest processingtime
+    private Task SPTRule(ItemList<Task> tasks) {
+      Task currentResult = RandomRule(tasks);
+      foreach (Task t in tasks) {
+        if (t.Duration.Value < currentResult.Duration.Value)
+          currentResult = t;
+      }
+      return currentResult;
+    }
+
+    //longest processing time    
+    private Task LPTRule(ItemList<Task> tasks) {
+      Task currentResult = RandomRule(tasks);
+      foreach (Task t in tasks) {
+        if (t.Duration.Value > currentResult.Duration.Value)
+          currentResult = t;
+      }
+      return currentResult;
+    } 
+
+    //most work remaining
+    private Task MWRRule(ItemList<Task> tasks) {
+      Task currentResult = RandomRule(tasks);
+      double currentLargestRemainingProcessingTime = 0;
+      foreach (Task t in tasks) {
+        double remainingProcessingTime = 0;
+        foreach (Task jt in jobs[t.JobNr.Value].Tasks) {
+          if (!jt.IsScheduled.Value)
+            remainingProcessingTime += jt.Duration.Value;
+        }
+        if (remainingProcessingTime > currentLargestRemainingProcessingTime) {
+          currentLargestRemainingProcessingTime = remainingProcessingTime;
+          currentResult = t;
+        }
+      }
+      return currentResult;
+    }
+   
+    //least work remaining
+    private Task LWRRule(ItemList<Task> tasks) {
+      Task currentResult = RandomRule(tasks);
+      double currentSmallestRemainingProcessingTime = double.MaxValue;
+      foreach (Task t in tasks) {
+        double remainingProcessingTime = 0;
+        foreach (Task jt in jobs[t.JobNr.Value].Tasks) {
+          if (!jt.IsScheduled.Value)
+            remainingProcessingTime += jt.Duration.Value;
+        }
+        if (remainingProcessingTime < currentSmallestRemainingProcessingTime) {
+          currentSmallestRemainingProcessingTime = remainingProcessingTime;
+          currentResult = t;
+        }
+      }
+      return currentResult;
+    }
+
+    //most operations remaining
+    private Task MORRule(ItemList<Task> tasks) {
+      Task currentResult = RandomRule(tasks);
+      int currentLargestNrOfRemainingTasks = 0;
+      foreach (Task t in tasks) {
+        int nrOfRemainingTasks = 0;
+        foreach (Task jt in jobs[t.JobNr.Value].Tasks) {
+          if (!jt.IsScheduled.Value)
+            nrOfRemainingTasks++;
+        }
+        if (currentLargestNrOfRemainingTasks < nrOfRemainingTasks) {
+          currentLargestNrOfRemainingTasks = nrOfRemainingTasks;
+          currentResult = t;
+        }
+      }
+      return currentResult;
+    }
+    
+    //least operationsremaining
+    private Task LORRule(ItemList<Task> tasks) {
+      Task currentResult = RandomRule(tasks);
+      int currentSmallestNrOfRemainingTasks = int.MaxValue;
+      foreach (Task t in tasks) {
+        int nrOfRemainingTasks = 0;
+        foreach (Task jt in jobs[t.JobNr.Value].Tasks) {
+          if (!jt.IsScheduled.Value)
+            nrOfRemainingTasks++;
+        }
+        if (currentSmallestNrOfRemainingTasks > nrOfRemainingTasks) {
+          currentSmallestNrOfRemainingTasks = nrOfRemainingTasks;
+          currentResult = t;
+        }
+      }
+      return currentResult;
+    }
+                
+    //first operation in Queue
+    private Task FIFORule(ItemList<Task> tasks) {
+      Task currentResult = tasks[0];
+      return currentResult;
+    }
+                  
+    //random
+    private Task RandomRule(ItemList<Task> tasks) {
+      Task currentResult = tasks[RandomParameter.ActualValue.Next(tasks.Count)];
+      return currentResult;
+    }
+
+    #endregion
+
+    public PRVDecoder()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<ItemList<Job>>("JobData", "Job data taken from the JSSP - Instance."));
+    }
+
+    private ItemList<Task> GetEarliestNotScheduledTasks() {
+      ItemList<Task> result = new ItemList<Task>();
+      foreach (Job j in jobs) {
+        foreach (Task t in j.Tasks) {
+          if (!t.IsScheduled.Value) {
+            result.Add(t);
+            break;
+          }
+        }
+      }
+      return result;
+    }
+    private Task GetTaskWithMinimalEC(ItemList<Task> earliestTasksList) {
+      double minEct = double.MaxValue;
+      Task result = null;
+      foreach (Task t in earliestTasksList) {
+        double ect = GTAlgorithmUtils.ComputeEarliestCompletionTime(t, resultingSchedule);
+        if (ect < minEct) {
+          result = t;
+          minEct = ect;
+        }
+      }
+      return result;
+    }
+    private ItemList<Task> GetConflictSetForTask(Task conflictedTask, ItemList<Task> earliestTasksList) {
+      ItemList<Task> result = new ItemList<Task>();
+      double conflictedCompletionTime = GTAlgorithmUtils.ComputeEarliestCompletionTime(conflictedTask, resultingSchedule);
+      foreach (Task t in earliestTasksList) {
+        if (t.ResourceNr.Value == conflictedTask.ResourceNr.Value) {
+          if (GTAlgorithmUtils.ComputeEarliestStartTime(t, resultingSchedule) < conflictedCompletionTime)
+            result.Add(t);
+        }
+      }
+      return result;
+    }
+    private Task SelectTaskFromConflictSet(ItemList<Task> conflictSet, int ruleIndex, int nrOfRules) {
+      if (conflictSet.Count == 1)
+        return conflictSet[0];
+      
+      ruleIndex = ruleIndex % nrOfRules;
+      switch (ruleIndex) {
+        case 0: return FILORule(conflictSet);
+        case 1: return ESTRule(conflictSet);
+        case 2: return SPTRule(conflictSet);
+        case 3: return LPTRule(conflictSet);
+        case 4: return MWRRule(conflictSet);
+        case 5: return LWRRule(conflictSet);
+        case 6: return MORRule(conflictSet);
+        case 7: return LORRule(conflictSet);
+        case 8: return FIFORule(conflictSet);
+        case 9: return RandomRule(conflictSet);
+        default: return RandomRule(conflictSet);
+      }  
+    }
+
+    public override Schedule CreateScheduleFromEncoding(PRVEncoding solution) {
+      jobs = (ItemList<Job>)JobDataParameter.ActualValue.Clone();
+      resultingSchedule = new Schedule(new IntValue(jobs[0].Tasks.Count));
+
+      //Reset scheduled tasks in result
+      foreach (Job j in jobs) {
+        foreach (Task t in j.Tasks) {
+          t.IsScheduled.Value = false;
+        }
+      }
+
+      //GT-Algorithm
+      //STEP 0 - Compute a list of "earliest operations"
+      ItemList<Task> earliestTasksList = GetEarliestNotScheduledTasks();
+      int currentDecisionIndex = 0;
+      while (earliestTasksList.Count > 0) {
+        //STEP 1 - Get earliest not scheduled operation with minimal earliest completing time
+        Task minimal = GetTaskWithMinimalEC(earliestTasksList);
+
+        //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 = GetConflictSetForTask(minimal, earliestTasksList);
+
+        //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);
+
+        //STEP 4 - Adding the selected operation to the current schedule
+        selectedTask.IsScheduled.Value = true;
+        double startTime = GTAlgorithmUtils.ComputeEarliestStartTime (selectedTask, resultingSchedule);
+        resultingSchedule.ScheduleTask(selectedTask.ResourceNr.Value, startTime, selectedTask.Duration.Value, selectedTask.JobNr.Value);
+
+        //STEP 5 - Back to STEP 1
+        earliestTasksList = GetEarliestNotScheduledTasks();
+      }
+
+      return resultingSchedule;
+    }
+
+    public override IOperation Apply() {
+      return base.Apply();
+    } 
+  }
+}
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/PWRDecoder.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/PWRDecoder.cs	(revision 6293)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/PWRDecoder.cs	(revision 6293)
@@ -0,0 +1,80 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SchedulingEncoding;
+using HeuristicLab.Encodings.SchedulingEncoding.PermutationWithRepetition;
+using HeuristicLab.Problems.Scheduling.Interfaces;
+
+namespace HeuristicLab.Problems.Scheduling.Decoders {
+  [Item("PWRDecoder", "An item used to convert a PWR-individual into a generalized schedule.")]
+  [StorableClass]
+  public class PWRDecoder : SchedulingDecoder<PWREncoding>, IStochasticOperator, IJSSPOperator {
+    [StorableConstructor]
+    protected PWRDecoder(bool deserializing) : base(deserializing) { }
+    protected PWRDecoder(PWRDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PWRDecoder(this, cloner);
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemList<Job>> JobDataParameter {
+      get { return (LookupParameter<ItemList<Job>>)Parameters["JobData"]; }
+    }
+
+    public PWRDecoder()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<ItemList<Job>>("JobData", "Job data taken from the JSSP - Instance."));
+    }
+
+    public override Schedule CreateScheduleFromEncoding(PWREncoding solution) {
+      ItemList<Job> jobs = (ItemList<Job>)JobDataParameter.ActualValue.Clone();
+      Schedule resultingSchedule = new Schedule(new IntValue(jobs[0].Tasks.Count));
+      foreach (int jobNr in solution.PermutationWithRepetition) {
+        int i = 0;
+        while (jobs[jobNr].Tasks[i].IsScheduled.Value) i++;
+        Task currentTask = jobs[jobNr].Tasks[i];
+        double startTime = GTAlgorithmUtils.ComputeEarliestStartTime (currentTask, resultingSchedule);
+        currentTask.IsScheduled.Value = true;
+        resultingSchedule.ScheduleTask(currentTask.ResourceNr.Value,startTime, currentTask.Duration.Value, currentTask.JobNr.Value);
+      }
+      return resultingSchedule;
+    }
+
+    public override IOperation Apply() {
+      return base.Apply();
+    } 
+  }
+}
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/MakespanEvaluator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/MakespanEvaluator.cs	(revision 6292)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/MakespanEvaluator.cs	(revision 6293)
@@ -30,4 +30,5 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
+using HeuristicLab.Encodings.SchedulingEncoding;
 
 namespace HeuristicLab.Problems.Scheduling.Evaluators {
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/MeanTardinessEvaluator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/MeanTardinessEvaluator.cs	(revision 6292)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/MeanTardinessEvaluator.cs	(revision 6293)
@@ -30,10 +30,10 @@
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Problems.Scheduling.Interfaces;
+using HeuristicLab.Encodings.SchedulingEncoding;
 
 namespace HeuristicLab.Problems.Scheduling.Evaluators {
   [Item("Men tardiness Evaluator", "Represents an evaluator using the mean tardiness of a schedule.")]
   [StorableClass]
-  public class MeanTardinessEvaluator : SchedulingEvaluator, IJSSPOperator {
+  public class MeanTardinessEvaluator : SchedulingEvaluator {
     [StorableConstructor]
     protected MeanTardinessEvaluator(bool deserializing) : base(deserializing) { }
@@ -46,10 +46,10 @@
 
     #region Parameter Properties
-    public ILookupParameter<ItemList<JSSPJob>> JobsParameter {
-      get { return (ILookupParameter<ItemList<JSSPJob>>)Parameters["Jobs"]; }
+    public ILookupParameter<ItemList<Job>> JobsParameter {
+      get { return (ILookupParameter<ItemList<Job>>)Parameters["Jobs"]; }
     }
     #endregion
     #region Properties
-    public ItemList<JSSPJob> Jobs {
+    public ItemList<Job> Jobs {
       get { return JobsParameter.ActualValue; }
     }
@@ -57,5 +57,5 @@
 
     public MeanTardinessEvaluator() : base() {
-      Parameters.Add(new LookupParameter<ItemList<JSSPJob>>("Jobs", "Jobdata defining the precedence relationships and the duration of the tasks in this JSSP-Instance."));
+      Parameters.Add(new LookupParameter<ItemList<Job>>("Jobs", "Jobdata defining the precedence relationships and the duration of the tasks in this JSSP-Instance."));
     }
 
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/SchedulingEvaluationAlgorithm.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/SchedulingEvaluationAlgorithm.cs	(revision 6292)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/SchedulingEvaluationAlgorithm.cs	(revision 6293)
@@ -31,7 +31,6 @@
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HeuristicLab.Problems.Scheduling.Interfaces;
-using HeuristicLab.Problems.Scheduling.Encodings;
-using HeuristicLab.Problems.Scheduling.Encodings.JobShopScheduling.JobSequenceMatrix;
+using HeuristicLab.Encodings.SchedulingEncoding.Interfaces;
+using HeuristicLab.Encodings.SchedulingEncoding;
 
 namespace HeuristicLab.Problems.Scheduling.Evaluators {
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/SchedulingEvaluator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/SchedulingEvaluator.cs	(revision 6292)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Evaluators/SchedulingEvaluator.cs	(revision 6293)
@@ -29,7 +29,7 @@
 using HeuristicLab.Parameters;
 using System;
-using HeuristicLab.Problems.Scheduling.Encodings;
 using HeuristicLab.Operators;
-using HeuristicLab.Problems.Scheduling.Interfaces;
+using HeuristicLab.Encodings.SchedulingEncoding.Interfaces;
+using HeuristicLab.Encodings.SchedulingEncoding;
 
 
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/HeuristicLab.Problems.Scheduling-3.3.csproj
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/HeuristicLab.Problems.Scheduling-3.3.csproj	(revision 6292)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/HeuristicLab.Problems.Scheduling-3.3.csproj	(revision 6293)
@@ -50,68 +50,24 @@
     <Compile Include="Analyzers\BestSchedulingSolutionAnalyzer.cs" />
     <Compile Include="Analyzers\SchedulingAnalyzer.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JSSPManipulator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JSSPDecoder.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JSSPCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\JSMDecodingErrorPolicyTypes.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\Crossovers\JSMJOXCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\Crossovers\JSMCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\Crossovers\JSMOXCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\Crossovers\JSMSXXCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\JSMDecoder.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\JSMForcingStrategyTypes.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\JSMRandomCreator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\JSMEncoding.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\Manipulators\JSMShiftChangeManipulator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\Manipulators\JSMManipulator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JobSequenceMatrix\Manipulators\JSMSwapManipulator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JSSPCreator.cs" />
-    <Compile Include="Encodings\SchedulingCrossover.cs" />
-    <Compile Include="Encodings\SchedulingDecoder.cs" />
-    <Compile Include="Encodings\JobShopScheduling\JSSPEncodingTypes.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PermutationWithRepetition\Crossovers\PWRGOXCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PermutationWithRepetition\Crossovers\PWRCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PermutationWithRepetition\Crossovers\PWRPPXCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PermutationWithRepetition\Manipulators\PWRUniformOnePositionManipulator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PermutationWithRepetition\Manipulators\PWRManipulator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PermutationWithRepetition\PWRDecoder.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PermutationWithRepetition\PWREncoding.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PermutationWithRepetition\PWRRandomCreator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PriorityRulesVector\Crossovers\PRVSinglePointCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PriorityRulesVector\Crossovers\PRVDiscreteCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PriorityRulesVector\Manipulators\PRVUniformOnePositionManipulator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PriorityRulesVector\PRVEncoding.cs" />
+    <Compile Include="Decoders\GTAlgorithmUtils.cs" />
+    <Compile Include="Decoders\JSMDecoder.cs" />
+    <Compile Include="Decoders\JSMDecodingErrorPolicyTypes.cs" />
+    <Compile Include="Decoders\JSMForcingStrategyTypes.cs" />
+    <Compile Include="Decoders\PRVDecoder.cs" />
+    <Compile Include="Decoders\PWRDecoder.cs" />
     <Compile Include="Evaluators\SchedulingEvaluatorType.cs" />
     <Compile Include="Evaluators\SchedulingEvaluatorTypes.cs" />
     <Compile Include="Evaluators\MeanTardinessEvaluator.cs" />
-    <Compile Include="Interfaces\IJSSPEncoding.cs" />
-    <Compile Include="Interfaces\ISchedulingDecoder.cs" />
-    <Compile Include="Interfaces\ISchedulingOperator.cs" />
-    <Compile Include="Interfaces\IPWROperator.cs" />
-    <Compile Include="Interfaces\IPRVOperator.cs" />
-    <Compile Include="Interfaces\ISchedulingEncoding.cs" />
-    <Compile Include="Encodings\SchedulingCreator.cs" />
-    <Compile Include="Encodings\SchedulingManipulator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PriorityRulesVector\Crossovers\PRVCrossover.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PriorityRulesVector\PRVDecoder.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PriorityRulesVector\PRVRandomCreator.cs" />
-    <Compile Include="Encodings\JobShopScheduling\PriorityRulesVector\Manipulators\PRVManipulator.cs" />
     <Compile Include="Evaluators\MakespanEvaluator.cs" />
+    <Compile Include="Evaluators\SchedulingEvaluator.cs" />
     <Compile Include="IndexedTaskList.cs" />
-    <Compile Include="Interfaces\IJSMOperator.cs" />
-    <Compile Include="Interfaces\ISchedulingCrossover.cs" />
-    <Compile Include="Interfaces\ISchedulingManipulator.cs" />
-    <Compile Include="Interfaces\ISchedulingCreator.cs" />
-    <Compile Include="Interfaces\ISchedulingEvaluator.cs" />
-    <Compile Include="Resource.cs" />
-    <Compile Include="Evaluators\SchedulingEvaluator.cs" />
-    <Compile Include="JSSPJob.cs" />
+    <Compile Include="Interfaces\IJSSPOperator.cs" />
+    <Compile Include="Job.cs" />
     <Compile Include="JobShopSchedulingProblem.cs" />
-    <Compile Include="JSSPTask.cs" />
-    <Compile Include="Interfaces\IJSSPOperator.cs" />
     <Compile Include="Evaluators\SchedulingEvaluationAlgorithm.cs" />
+    <Compile Include="Task.cs" />
     <Compile Include="SchedulingProblem.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Schedule.cs" />
   </ItemGroup>
   <ItemGroup>
@@ -148,4 +104,8 @@
       <Project>{DBECB8B0-B166-4133-BAF1-ED67C3FD7FCA}</Project>
       <Name>HeuristicLab.Encodings.PermutationEncoding-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.SchedulingEncoding\3.3\HeuristicLab.Encodings.SchedulingEncoding-3.3.csproj">
+      <Project>{17F3EF80-B2C3-4B8D-A4D5-BE9CE3BA2606}</Project>
+      <Name>HeuristicLab.Encodings.SchedulingEncoding-3.3</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/IndexedTaskList.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/IndexedTaskList.cs	(revision 6292)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/IndexedTaskList.cs	(revision 6293)
@@ -45,39 +45,19 @@
     }
 
-    #region Parameter Properties
-    public ValueParameter<IntValue> IndexParameter {
-      get { return (ValueParameter<IntValue>)Parameters["Index"]; }
+
+    public IntValue Index {
+      get;
+      set;
     }
-    public ValueParameter<ItemList<JSSPTask>> TasksParameter {
-      get { return (ValueParameter<ItemList<JSSPTask>>)Parameters["Tasks"]; }
-    }
-    #endregion
-
-    #region Properties
-    public IntValue Index {
-      get { return IndexParameter.Value; }
-      set { IndexParameter.Value = value; }
-    }
-    public ItemList<JSSPTask> Tasks {
-      get { return TasksParameter.Value; }
-      set { TasksParameter.Value = value; }
-    }
-    #endregion
-
-    public DoubleValue TotalDuration {
-      get {
-        double result = 0;
-        foreach (JSSPTask t in Tasks) {
-          if (t.EndTime.Value > result)
-            result = t.EndTime.Value;
-        }
-        return new DoubleValue(result);
-      }
+    public ItemList<Task> Tasks {
+      get;
+      set;
     }
 
-    public IndexedTaskList (IntValue index) : base (){
-      Parameters.Add(new ValueParameter<IntValue>("Index", "The index of the resource in the associated Scheduling Problem.", new IntValue()));
-      Parameters.Add(new ValueParameter<ItemList<JSSPTask>>("Tasks", "Taskdata defining duration, start-time and resource assignment of the tasks.", new ItemList<JSSPTask>()));
+
+    public IndexedTaskList(IntValue index)
+      : base() {
       Index = index;
+      Tasks = new ItemList<Task>();
     }
 
@@ -85,5 +65,5 @@
       StringBuilder sb = new StringBuilder();
       sb.Append("TaskList#" + Index + " [ ");
-      foreach (JSSPTask t in Tasks) {
+      foreach (Task t in Tasks) {
         sb.Append(t.ToString() + " ");
       }
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/IJSMOperator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/IJSMOperator.cs	(revision 6292)
+++ 	(revision )
@@ -1,10 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  interface IJSMOperator : IOperator {
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/IJSSPEncoding.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/IJSSPEncoding.cs	(revision 6292)
+++ 	(revision )
@@ -1,30 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  public interface IJSSPEncoding : ISchedulingEncoding{
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/IJSSPOperator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/IJSSPOperator.cs	(revision 6292)
+++ 	(revision )
@@ -1,39 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Operators;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Parameters;
-using HeuristicLab.Data;
-using HeuristicLab.Problems.Scheduling.Interfaces;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  public interface IJSSPOperator : ISchedulingOperator{
-    ILookupParameter<ItemList<JSSPJob>> JobsParameter { get; }
-    ItemList<JSSPJob> Jobs { get; }
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/IPRVOperator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/IPRVOperator.cs	(revision 6292)
+++ 	(revision )
@@ -1,10 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  interface IPRVOperator : IOperator {
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/IPWROperator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/IPWROperator.cs	(revision 6292)
+++ 	(revision )
@@ -1,10 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  interface IPWROperator : IOperator {
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingCreator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingCreator.cs	(revision 6292)
+++ 	(revision )
@@ -1,10 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  public interface ISchedulingCreator : ISolutionCreator {
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingCrossover.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingCrossover.cs	(revision 6292)
+++ 	(revision )
@@ -1,12 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Optimization;
-using HeuristicLab.Core;
-using HeuristicLab.Problems.Scheduling.Encodings;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  public interface ISchedulingCrossover : ICrossover{
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingDecoder.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingDecoder.cs	(revision 6292)
+++ 	(revision )
@@ -1,37 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  public interface ISchedulingDecoder : IOperator {
-
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingEncoding.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingEncoding.cs	(revision 6292)
+++ 	(revision )
@@ -1,37 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.Scheduling.Encodings;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  public interface ISchedulingEncoding : IItem {
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingEvaluator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingEvaluator.cs	(revision 6292)
+++ 	(revision )
@@ -1,10 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  public interface ISchedulingEvaluator : ISingleObjectiveEvaluator {
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingManipulator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingManipulator.cs	(revision 6292)
+++ 	(revision )
@@ -1,29 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 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.Optimization;
-using HeuristicLab.Problems.Scheduling.Encodings;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  public interface ISchedulingManipulator : IManipulator {
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingOperator.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Interfaces/ISchedulingOperator.cs	(revision 6292)
+++ 	(revision )
@@ -1,10 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.Scheduling.Interfaces {
-  public interface ISchedulingOperator : IOperator {
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/JSSPJob.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/JSSPJob.cs	(revision 6292)
+++ 	(revision )
@@ -1,74 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-
-namespace HeuristicLab.Problems.Scheduling {
-  [Item("Job Class", "Represents a composition of tasks that require processing in a job shop scheduling problem.")]
-  [StorableClass]
-  public class JSSPJob : IndexedTaskList {
-    [StorableConstructor]
-    protected JSSPJob(bool deserializing) : base(deserializing) { }
-    protected JSSPJob(JSSPJob original, Cloner cloner)
-      : base(original, cloner) {
-        this.DueDate = cloner.Clone(original.DueDate);
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new JSSPJob(this, cloner);
-    }
-
-    public DoubleValue DueDate { get; set; }
-
-    public JSSPJob(IntValue index, DoubleValue dueDate) : base (index) {
-      if (dueDate != null)
-        DueDate = (DoubleValue)dueDate.Clone();
-      else
-        DueDate = null;
-    }
-
-    public override string ToString() {
-      StringBuilder sb = new StringBuilder();
-      sb.Append("Job#" + Index + " [ ");
-      foreach (JSSPTask t in Tasks) {
-        sb.Append(t.ToString () + " ");
-      }
-      if (DueDate != null)
-        sb.Append("{" + DueDate.Value + "} ");
-      sb.Append("]");
-      return sb.ToString();
-    }
-
-    internal JSSPTask GetPreviousTask(JSSPTask t) {
-      if (t.TaskNr.Value == 0)
-        return null;
-      else
-        return Tasks[t.TaskNr.Value - 1];
-    }
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/JSSPTask.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/JSSPTask.cs	(revision 6292)
+++ 	(revision )
@@ -1,79 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Data;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-
-namespace HeuristicLab.Problems.Scheduling {
-  [Item("Job Shop Scheduling Task Class", "Represents smallest unit for a job shop scheduling problem.")]
-  [StorableClass]
-  public class JSSPTask : Item {
-    [StorableConstructor]
-    protected JSSPTask(bool deserializing) : base(deserializing) { }
-    protected JSSPTask(JSSPTask original, Cloner cloner)
-      : base(original, cloner) {
-      this.ResourceNr = cloner.Clone(original.ResourceNr);
-      this.Duration = cloner.Clone(original.Duration);
-      this.StartTime = cloner.Clone(original.StartTime);
-      this.TaskNr = cloner.Clone(original.TaskNr);
-      this.IsScheduled = cloner.Clone(original.IsScheduled);
-      this.JobNr = cloner.Clone (original.JobNr);
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new JSSPTask(this, cloner);
-    }
-
-
-    public BoolValue IsScheduled { get; set; }
-    public IntValue TaskNr { get; set; }
-    public IntValue ResourceNr { get; set; }
-    public DoubleValue Duration { get; set; }
-    public DoubleValue StartTime { get; set; }
-    public DoubleValue EndTime {
-      get {
-        return new DoubleValue(Duration.Value + StartTime.Value);
-      }
-    }
-    public IntValue JobNr { get; set; }
-
-
-    public JSSPTask (IntValue taskNr, IntValue resNr, DoubleValue duration, IntValue jobNr) : base () {
-      Duration = duration;
-      ResourceNr = resNr;
-      TaskNr = taskNr;
-      StartTime = new DoubleValue(0);
-      IsScheduled = new BoolValue(false);
-      JobNr = jobNr;
-    }
-
-    public override string ToString() {
-      StringBuilder sb = new StringBuilder();
-      sb.Append("[" + JobNr + "," + ResourceNr + "]");
-      return sb.ToString();
-    }
-  }
-}
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Job.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Job.cs	(revision 6293)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Job.cs	(revision 6293)
@@ -0,0 +1,74 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.Scheduling {
+  [Item("Job Class", "Represents a composition of tasks that require processing in a job shop scheduling problem.")]
+  [StorableClass]
+  public class Job : IndexedTaskList {
+    [StorableConstructor]
+    protected Job(bool deserializing) : base(deserializing) { }
+    protected Job(Job original, Cloner cloner)
+      : base(original, cloner) {
+        this.DueDate = cloner.Clone(original.DueDate);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Job(this, cloner);
+    }
+
+    public DoubleValue DueDate { get; set; }
+
+    public Job(IntValue index, DoubleValue dueDate) : base (index) {
+      if (dueDate != null)
+        DueDate = (DoubleValue)dueDate.Clone();
+      else
+        DueDate = null;
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("Job#" + Index + " [ ");
+      foreach (Task t in Tasks) {
+        sb.Append(t.ToString () + " ");
+      }
+      if (DueDate != null)
+        sb.Append("{" + DueDate.Value + "} ");
+      sb.Append("]");
+      return sb.ToString();
+    }
+
+    internal Task GetPreviousTask(Task t) {
+      if (t.TaskNr.Value == 0)
+        return null;
+      else
+        return Tasks[t.TaskNr.Value - 1];
+    }
+  }
+}
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/JobShopSchedulingProblem.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/JobShopSchedulingProblem.cs	(revision 6292)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/JobShopSchedulingProblem.cs	(revision 6293)
@@ -31,16 +31,15 @@
 using HeuristicLab.Data;
 using System.IO;
-using HeuristicLab.Problems.Scheduling.Encodings;
 using HeuristicLab.Problems.Scheduling.Evaluators;
 using HeuristicLab.Parameters;
-using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Problems.Scheduling.Analyzers;
 using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.Problems.Scheduling.Interfaces;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Problems.Scheduling.Encodings.JobShopScheduling;
-using HeuristicLab.Problems.Scheduling.Encodings.JobShopScheduling.JobSequenceMatrix;
-using HeuristicLab.Problems.Scheduling.Encodings.JobShopScheduling.PriorityRulesVector;
-using HeuristicLab.Problems.Scheduling.Encodings.JobShopScheduling.PermutationWithRepetition;
+using HeuristicLab.Encodings.SchedulingEncoding;
+using HeuristicLab.Encodings.SchedulingEncoding.Interfaces;
+using HeuristicLab.Encodings.SchedulingEncoding.JobSequenceMatrix;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.SchedulingEncoding.PriorityRulesVector;
+using HeuristicLab.Encodings.SchedulingEncoding.PermutationWithRepetition;
+using HeuristicLab.Problems.Scheduling.Decoders;
 
 namespace HeuristicLab.Problems.Scheduling {
@@ -64,6 +63,6 @@
 
     #region Parameter Properties
-    public ValueParameter<ItemList<JSSPJob>> JobsParameter {
-      get { return (ValueParameter<ItemList<JSSPJob>>)Parameters["Jobs"]; }
+    public ValueParameter<ItemList<Job>> JobDataParameter {
+      get { return (ValueParameter<ItemList<Job>>)Parameters["JobData"]; }
     }
     public ValueParameter<SchedulingEvaluatorType> EvaluatorTypeParameter {
@@ -74,10 +73,17 @@
     }
 
+    public ValueParameter<IntValue> JobsParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Jobs"]; }
+    }
+    public ValueParameter<IntValue> ResourcesParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Resources"]; }
+    }
+
     #endregion
 
     #region Properties
-    public ItemList<JSSPJob> Jobs {
-      get { return JobsParameter.Value; }
-      set { JobsParameter.Value = value; }
+    public ItemList<Job> JobData {
+      get { return JobDataParameter.Value; }
+      set { JobDataParameter.Value = value; }
     }
     public SchedulingEvaluatorType EvaluatorType {
@@ -89,15 +95,26 @@
       set { BestKnownSolutionParameter.Value = value; }
     }
+    public IntValue Jobs {
+      get { return JobsParameter.Value; }
+      set { JobsParameter.Value = value; }
+    }
+    public IntValue Resources {
+      get { return ResourcesParameter.Value; }
+      set { ResourcesParameter.Value = value; }
+    }
     #endregion
 
     [Storable]
-    private JSSPEncodingTypes encodingType;
+    private SchedulingEncodingTypes encodingType;
 
     public JobShopSchedulingProblem()
       : base(new SchedulingEvaluationAlgorithm (), new JSMRandomCreator ()) {
-      Parameters.Add(new ValueParameter<ItemList<JSSPJob>>("Jobs", "Jobdata defining the precedence relationships and the duration of the tasks in this JSSP-Instance.", new ItemList<JSSPJob>()));
-      Parameters.Add(new ValueParameter<SchedulingEvaluatorType>("EvaluatorType", "Type of the evaluator used to determine the quality of an individual.", new SchedulingEvaluatorType (SchedulingEvaluatorTypes.MakespanEvaluator)));
-      Parameters.Add(new OptionalValueParameter<Schedule>("BestKnownSolution", "The best known solution of this JSSP instance.")); 
-        encodingType = JSSPEncodingTypes.JSMEncoding;
+      Parameters.Add(new ValueParameter<ItemList<Job>>("JobData", "Jobdata defining the precedence relationships and the duration of the tasks in this JSSP-Instance.", new ItemList<Job>()));
+      Parameters.Add(new ValueParameter<SchedulingEvaluatorType>("EvaluatorType", "Type of the evaluator used to determine the quality of an individual.", new SchedulingEvaluatorType(SchedulingEvaluatorTypes.MakespanEvaluator)));
+      Parameters.Add(new OptionalValueParameter<Schedule>("BestKnownSolution", "The best known solution of this JSSP instance."));
+      
+      Parameters.Add(new ValueParameter<IntValue>("Jobs", "The number of jobs used in this JSSP instance.", new IntValue ()));
+      Parameters.Add(new ValueParameter<IntValue>("Resources", "The number of resources used this JSSP instance.", new IntValue()));
+      encodingType = SchedulingEncodingTypes.JSMEncoding;
         InitializeOperators();
         AttachEventHandlers();
@@ -108,10 +125,10 @@
     protected override void OnSolutionCreatorChanged() {
       if (SolutionCreator.GetType().Equals(typeof(JSMRandomCreator)))
-        encodingType = JSSPEncodingTypes.JSMEncoding;
+        encodingType = SchedulingEncodingTypes.JSMEncoding;
       else {
         if (SolutionCreator.GetType().Equals(typeof(PRVRandomCreator)))
-          encodingType = JSSPEncodingTypes.PRVEncoding;
+          encodingType = SchedulingEncodingTypes.PRVEncoding;
         else
-          encodingType = JSSPEncodingTypes.PWREncoding;
+          encodingType = SchedulingEncodingTypes.PWREncoding;
       }
       InitializeOperators();
@@ -130,13 +147,13 @@
     private void ApplyEncoding() {
       if (EvaluatorType.Value == SchedulingEvaluatorTypes.MakespanEvaluator) {
-        if (encodingType == JSSPEncodingTypes.JSMEncoding) {
+        if (encodingType == SchedulingEncodingTypes.JSMEncoding) {
           Operators.AddRange(ApplicationManager.Manager.GetInstances<IJSMOperator>());
           ((SchedulingEvaluationAlgorithm)this.EvaluatorParameter.ActualValue).InitializeOperatorGraph<JSMEncoding>(new JSMDecoder(), new MakespanEvaluator());
         } else {
-          if (encodingType == JSSPEncodingTypes.PRVEncoding) {
+          if (encodingType == SchedulingEncodingTypes.PRVEncoding) {
             Operators.AddRange(ApplicationManager.Manager.GetInstances<IPRVOperator>());
             ((SchedulingEvaluationAlgorithm)this.EvaluatorParameter.ActualValue).InitializeOperatorGraph<PRVEncoding>(new PRVDecoder(), new MakespanEvaluator());
           } else {
-            if (encodingType == JSSPEncodingTypes.PWREncoding) {
+            if (encodingType == SchedulingEncodingTypes.PWREncoding) {
               Operators.AddRange(ApplicationManager.Manager.GetInstances<IPWROperator>());
               ((SchedulingEvaluationAlgorithm)this.EvaluatorParameter.ActualValue).InitializeOperatorGraph<PWREncoding>(new PWRDecoder(), new MakespanEvaluator());
@@ -145,13 +162,13 @@
         }
       } else {
-        if (encodingType == JSSPEncodingTypes.JSMEncoding) {
+        if (encodingType == SchedulingEncodingTypes.JSMEncoding) {
           Operators.AddRange(ApplicationManager.Manager.GetInstances<IJSMOperator>());
           ((SchedulingEvaluationAlgorithm)this.EvaluatorParameter.ActualValue).InitializeOperatorGraph<JSMEncoding>(new JSMDecoder(), new MeanTardinessEvaluator());
         } else {
-          if (encodingType == JSSPEncodingTypes.PRVEncoding) {
+          if (encodingType == SchedulingEncodingTypes.PRVEncoding) {
             Operators.AddRange(ApplicationManager.Manager.GetInstances<IPRVOperator>());
             ((SchedulingEvaluationAlgorithm)this.EvaluatorParameter.ActualValue).InitializeOperatorGraph<PRVEncoding>(new PRVDecoder(), new MeanTardinessEvaluator());
           } else {
-            if (encodingType == JSSPEncodingTypes.PWREncoding) {
+            if (encodingType == SchedulingEncodingTypes.PWREncoding) {
               Operators.AddRange(ApplicationManager.Manager.GetInstances<IPWROperator>());
               ((SchedulingEvaluationAlgorithm)this.EvaluatorParameter.ActualValue).InitializeOperatorGraph<PWREncoding>(new PWRDecoder(), new MeanTardinessEvaluator());
@@ -203,5 +220,5 @@
       bool problemFound = false;
 
-      Jobs = new ItemList<JSSPJob>();
+      JobData = new ItemList<Job>();
 
       while (!problemFile.EndOfStream && !problemFound) {
@@ -210,6 +227,6 @@
         if (data.Count > 0 && ((int)data[0][0] >= 48 && (int)data[0][0] <= 57)) {
           int jobCount = 0;
-          //data[0] = nrOfJobs (int)
-          //data[1] = nrOfResources (int)
+          Jobs = new IntValue (Int32.Parse(data[0]));
+          Resources = new IntValue (Int32.Parse(data[1]));
           //data[2] = bestKnownQuality (double)
           //data[3] = dueDates (0|1)
@@ -228,14 +245,11 @@
               dataCount--;
             }
-            JSSPJob j = new JSSPJob(new IntValue(jobCount), dueDate);
+            Job j = new Job(new IntValue(jobCount), dueDate);
             for (int i = 0; i < dataCount; i++) {
-              JSSPTask t = new JSSPTask(new IntValue (i / 2), new IntValue(Int32.Parse(data[i])), new DoubleValue(Double.Parse(data[i + 1])), new IntValue (jobCount));
-              if (j.Tasks.Count > 0) {
-                t.StartTime = new DoubleValue (j.Tasks[j.Tasks.Count - 1].EndTime.Value + 2);
-              }
+              Task t = new Task(i / 2, Int32.Parse(data[i]), jobCount, Double.Parse(data[i + 1]));
               j.Tasks.Add(t);
               i++;
             }//for
-            this.Jobs.Add(j);
+            this.JobData.Add(j);
             jobCount++;
             line = problemFile.ReadLine();
@@ -277,5 +291,5 @@
 
       JSMDecoder decoder = new JSMDecoder();
-      Schedule result = decoder.CreateScheduleFromEncoding(solution, Jobs);
+      Schedule result = decoder.CreateScheduleFromEncoding(solution, JobData);
       BestKnownSolution = result;
     }
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Plugin.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Plugin.cs	(revision 6293)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Plugin.cs	(revision 6293)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 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.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.Scheduling {
+  [Plugin("HeuristicLab.Problems.Scheduling", "3.3.3.6266")]
+  [PluginFile("HeuristicLab.Problems.Scheduling-3.3.dll", PluginFileType.Assembly)]
+  public class HeuristicLabProblemsSchedulingPlugin : PluginBase {
+  }
+}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Resource.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Resource.cs	(revision 6292)
+++ 	(revision )
@@ -1,57 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Data;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-
-namespace HeuristicLab.Problems.Scheduling {
-  [Item("Resource Class", "Represents a resource used in scheduling problems.")]
-  [StorableClass]
-  public class Resource : IndexedTaskList {
-    [StorableConstructor]
-    protected Resource(bool deserializing) : base(deserializing) { }
-    protected Resource(Resource original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Resource(this, cloner);
-    }
-
-    public Resource(IntValue index) : base (index) { }
-
-    public override string ToString() {
-      StringBuilder sb = new StringBuilder();
-      sb.Append("Resource#" + Index + " [ ");
-      foreach (JSSPTask t in Tasks) {
-        sb.Append(t.ToString() + " ");
-      }
-      sb.Append("]");
-      return sb.ToString();
-    }
-  }
-}
Index: anches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Schedule.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Schedule.cs	(revision 6292)
+++ 	(revision )
@@ -1,166 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Parameters;
-using HeuristicLab.Encodings.PermutationEncoding;
-using System.ComponentModel;
-
-namespace HeuristicLab.Problems.Scheduling {
-  [Item("Schedule Class", "Represents the general solution for scheduling problems.")]
-  [StorableClass]
-  public class Schedule : NamedItem{
-    [StorableConstructor]
-    protected Schedule(bool deserializing) : base(deserializing) { }
-    protected Schedule(Schedule original, Cloner cloner)
-      : base(original, cloner) {
-        this.Resources = cloner.Clone (original.Resources);
-        this.Quality = cloner.Clone(original.Quality);
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Schedule(this, cloner);
-    }
-
-    [Storable]
-    private ItemList<Resource> resources;
-    public ItemList<Resource> Resources {
-      get { return resources; }
-      set {
-        if (resources != null) DeregisterResourcesEvents();
-        resources = value;
-        if (resources != null) RegisterResourcesEvents();
-        OnResourcesChanged();
-      }
-    }
-
-    [Storable]
-    private DoubleValue quality;
-    public DoubleValue Quality {
-      get { return quality; }
-      set {
-        if (quality != value) {
-          if (quality != null) DeregisterQualityEvents();
-          quality = value;
-          if (quality != null) RegisterQualityEvents();
-          OnQualityChanged();
-        }
-      }
-    }
-
-    public double Makespan {
-      get {
-        double quality = 0;
-        foreach (Resource r in Resources) {
-          if (r.TotalDuration.Value > quality) {
-            quality = r.TotalDuration.Value;
-          }
-        }
-        return quality;
-      }
-    }
-
-    public Schedule(IntValue nrOfResources) {
-      Resources = new ItemList<Resource>();
-      Quality = new DoubleValue();
-      for (int i = 0; i < nrOfResources.Value; i++) {
-        Resources.Add(new Resource(new IntValue (i)));
-      }
-    }
-
-    #region Events
-    public event EventHandler QualityChanged;
-    private void OnQualityChanged() {
-      var changed = QualityChanged;
-      if (changed != null)
-        changed(this, EventArgs.Empty);
-    }
-    private void RegisterQualityEvents() {
-      Quality.ValueChanged += new EventHandler(Quality_ValueChanged);
-    }
-    private void DeregisterQualityEvents() {
-      Quality.ValueChanged -= new EventHandler(Quality_ValueChanged);
-    }
-    private void Quality_ValueChanged(object sender, EventArgs e) {
-      OnQualityChanged();
-    }
-
-    public event EventHandler ResourcesChanged;
-    private void OnResourcesChanged() {
-      var changed = ResourcesChanged;
-      if (changed != null)
-        changed(this, EventArgs.Empty);
-    }
-    private void RegisterResourcesEvents() {
-      Resources.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(Resources_PropertyChanged);
-    }
-    private void DeregisterResourcesEvents() {
-      Resources.PropertyChanged -= new System.ComponentModel.PropertyChangedEventHandler(Resources_PropertyChanged);
-    }
-    private void Resources_PropertyChanged(object sender, EventArgs e) {
-      OnResourcesChanged();
-    }
-    #endregion
-
-    public void AddTask(JSSPTask task, JSSPJob job) {
-      task.StartTime = new DoubleValue (ComputeEarliestStartTime(task, job));
-      Resource affectedResource = resources[task.ResourceNr.Value];
-      int i = 0;
-      while (i < affectedResource.Tasks.Count && affectedResource.Tasks[i].StartTime.Value < task.StartTime.Value)
-        i++;
-
-      if (i >= affectedResource.Tasks.Count)
-        affectedResource.Tasks.Add(task);
-      else
-        affectedResource.Tasks.Insert(i, task);
-    }
-    public double ComputeEarliestStartTime(JSSPTask t, JSSPJob job) {
-      Resource affectedResource = resources[t.ResourceNr.Value];
-      double lastMachineEndTime = affectedResource.TotalDuration.Value;
-      double previousJobTaskEndTime = 0;
-      JSSPTask previousTask = job.GetPreviousTask(t);
-      if (previousTask != null)
-        previousJobTaskEndTime = previousTask.EndTime.Value;
-
-      return Math.Max(previousJobTaskEndTime, lastMachineEndTime);
-    }
-    public double ComputeEarliestCompletionTime(JSSPTask t, JSSPJob job) {
-      Resource affectedResource = resources[t.ResourceNr.Value];
-      return ComputeEarliestStartTime(t, job) + t.Duration.Value;
-    }
-
-    public override string ToString() {
-      StringBuilder sb = new StringBuilder();
-      sb.Append("[ ");
-      foreach (Resource r in Resources) {
-        sb.Append(r.ToString () + " \n");
-      }
-      sb.Append("]");
-      return sb.ToString();
-    }
-  }
-}
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/SchedulingProblem.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/SchedulingProblem.cs	(revision 6292)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/SchedulingProblem.cs	(revision 6293)
@@ -28,5 +28,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Common;
-using HeuristicLab.Problems.Scheduling.Interfaces;
+using HeuristicLab.Encodings.SchedulingEncoding.Interfaces;
 
 namespace HeuristicLab.Problems.Scheduling {
Index: /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Task.cs
===================================================================
--- /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Task.cs	(revision 6293)
+++ /branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Task.cs	(revision 6293)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.Scheduling {
+  [Item("Task Class", "Represents a task that has been scheduled already.")]
+  [StorableClass]
+  public class Task : Item {
+    [StorableConstructor]
+    protected Task(bool deserializing) : base(deserializing) { }
+    protected Task(Task original, Cloner cloner)
+      : base(original, cloner) {
+      this.ResourceNr = cloner.Clone(original.ResourceNr);
+      this.JobNr = cloner.Clone(original.JobNr);
+      this.Duration = cloner.Clone(original.Duration);
+      this.TaskNr = cloner.Clone(original.TaskNr);
+      this.IsScheduled = cloner.Clone(original.IsScheduled);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Task(this, cloner);
+    }
+
+
+    public IntValue TaskNr { get; set; }
+    public IntValue ResourceNr { get; set; }
+    public IntValue JobNr { get; set; }
+    public DoubleValue Duration { get; set; }
+    public BoolValue IsScheduled { get; set; }
+
+
+    public Task (int taskNr, int resNr, int jobNr, double duration) : base () {
+      Duration = new DoubleValue (duration);
+      ResourceNr = new IntValue (resNr);
+      JobNr = new IntValue (jobNr);
+      TaskNr = new IntValue (taskNr);
+      IsScheduled = new BoolValue(false);
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("[" + TaskNr + "," + ResourceNr + "]");
+      return sb.ToString();
+    }
+  }
+}
