Index: branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/GTAlgorithmUtils.cs
===================================================================
--- branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/GTAlgorithmUtils.cs	(revision 6364)
+++ branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/GTAlgorithmUtils.cs	(revision 6406)
@@ -1,10 +1,28 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Encodings.SchedulingEncoding;
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Encodings.ScheduleEncoding;
 
-namespace HeuristicLab.Problems.Scheduling.Decoders {
+namespace HeuristicLab.Problems.Scheduling {
   public static class GTAlgorithmUtils {
 
@@ -45,7 +63,7 @@
       return result;
     }
-    
+
     public static double ComputeEarliestStartTime(Task t, Schedule schedule) {
-      ScheduledTask previousTask = schedule.GetLastScheduledTaskForJobNr (t.JobNr.Value);
+      ScheduledTask previousTask = schedule.GetLastScheduledTaskForJobNr(t.JobNr.Value);
       Resource affectedResource = schedule.Resources[t.ResourceNr.Value];
       double lastMachineEndTime = affectedResource.TotalDuration.Value;
Index: branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecoder.cs
===================================================================
--- branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecoder.cs	(revision 6364)
+++ branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecoder.cs	(revision 6406)
@@ -20,36 +20,19 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.ScheduleEncoding;
+using HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Encodings.SchedulingEncoding.JobSequenceMatrix;
-using HeuristicLab.Encodings.SchedulingEncoding;
-using HeuristicLab.Problems.Scheduling.Interfaces;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Scheduling.Decoders {
-  [Item("Job Sequence Matrix Decoder", "Applies the GifflerThompson algorithm to create an active schedule from a JobSequence Matrix.")]
+namespace HeuristicLab.Problems.Scheduling {
+  [Item("JobSequenceMatrixDecoder", "Applies the GifflerThompson algorithm to create an active schedule from a JobSequence 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 class JSMDecoder : ScheduleDecoder<JSMEncoding>, IStochasticOperator, IJSSPOperator {
     public ILookupParameter<IRandom> RandomParameter {
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
@@ -70,6 +53,19 @@
 
     [Storable]
-    private JSMForcingStrategyTypes forcingStrategy = JSMForcingStrategyTypes.ShiftForcing; 
+    private JSMForcingStrategyTypes forcingStrategy = JSMForcingStrategyTypes.ShiftForcing;
     #endregion
+
+    [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 JSMDecoder()
@@ -77,11 +73,12 @@
       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 Schedulingproblem - Instance."));
+      ScheduleEncodingParameter.ActualName = "JobSequenceMatrix";
     }
 
-    
+
     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];
@@ -104,5 +101,5 @@
     }
     private Task ApplyDecodingErrorPolicy(ItemList<Task> conflictSet, Permutation resource, int progress) {
-      if (decodingErrorPolicy == JSMDecodingErrorPolicyTypes.RandomPolicy) { 
+      if (decodingErrorPolicy == JSMDecodingErrorPolicyTypes.RandomPolicy) {
         //Random
         return conflictSet[RandomParameter.ActualValue.Next(conflictSet.Count - 1)];
@@ -118,5 +115,5 @@
         }
         return conflictSet[RandomParameter.ActualValue.Next(conflictSet.Count - 1)];
-      }    
+      }
     }
     private void ApplyForcingStrategy(ItemList<Permutation> jsm, int conflictedResource, int newResolutionIndex, int progressOnResource, int newResolution) {
@@ -132,9 +129,9 @@
           asList.Insert(progressOnResource, newResolution);
         } else {
-          asList.Insert(progressOnResource, newResolution); 
+          asList.Insert(progressOnResource, newResolution);
           asList.RemoveAt(newResolutionIndex);
         }
-        jsm[conflictedResource] = new Permutation (PermutationTypes.Absolute, asList.ToArray<int>());
-      } 
+        jsm[conflictedResource] = new Permutation(PermutationTypes.Absolute, asList.ToArray<int>());
+      }
     }
 
@@ -143,5 +140,5 @@
 
       jobs = (ItemList<Job>)jobData.Clone();
-      resultingSchedule = new Schedule(new IntValue(jobs[0].Tasks.Count));
+      resultingSchedule = new Schedule(jobs[0].Tasks.Count);
 
       //Reset scheduled tasks in result
@@ -186,5 +183,5 @@
     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 6364)
+++ branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMDecodingErrorPolicyTypes.cs	(revision 6406)
@@ -1,8 +1,23 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace HeuristicLab.Problems.Scheduling.Decoders {
+﻿#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
+namespace HeuristicLab.Problems.Scheduling {
   public enum JSMDecodingErrorPolicyTypes {
     RandomPolicy,
Index: branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMForcingStrategyTypes.cs
===================================================================
--- branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMForcingStrategyTypes.cs	(revision 6364)
+++ branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/JSMForcingStrategyTypes.cs	(revision 6406)
@@ -1,8 +1,24 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+﻿#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
 
-namespace HeuristicLab.Problems.Scheduling.Decoders {
+namespace HeuristicLab.Problems.Scheduling {
   public enum JSMForcingStrategyTypes {
     ShiftForcing,
Index: branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/PRVDecoder.cs
===================================================================
--- branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/PRVDecoder.cs	(revision 6364)
+++ branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/PRVDecoder.cs	(revision 6406)
@@ -20,182 +20,174 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.ScheduleEncoding;
+using HeuristicLab.Encodings.ScheduleEncoding.PriorityRulesVector;
 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.")]
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Scheduling {
+  [Item("JobSequencingMatrixDecoder", "Applies the GifflerThompson algorithm to create an active schedule from a JobSequencing Matrix.")]
   [StorableClass]
-  public class PRVDecoder : SchedulingDecoder<PRVEncoding>, IStochasticOperator, IJSSPOperator {
+  public class PRVDecoder : ScheduleDecoder<PRVEncoding>, IStochasticOperator, IJSSPOperator {
+    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
+
     [StorableConstructor]
     protected PRVDecoder(bool deserializing) : base(deserializing) { }
     protected PRVDecoder(PRVDecoder original, Cloner cloner)
       : base(original, cloner) {
-        this.resultingSchedule = cloner.Clone(original.resultingSchedule);
+      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."));
-    }
-
-
+      Parameters.Add(new LookupParameter<ItemList<Job>>("JobData", "Job data taken from the SchedulingProblem - Instance."));
+      ScheduleEncodingParameter.ActualName = "PriorityRulesVector";
+    }
 
     private Task SelectTaskFromConflictSet(ItemList<Task> conflictSet, int ruleIndex, int nrOfRules) {
@@ -221,5 +213,5 @@
     public override Schedule CreateScheduleFromEncoding(PRVEncoding solution) {
       jobs = (ItemList<Job>)JobDataParameter.ActualValue.Clone();
-      resultingSchedule = new Schedule(new IntValue(jobs[0].Tasks.Count));
+      resultingSchedule = new Schedule(jobs[0].Tasks.Count);
 
       //Reset scheduled tasks in result
@@ -247,5 +239,5 @@
         //STEP 4 - Adding the selected operation to the current schedule
         selectedTask.IsScheduled.Value = true;
-        double startTime = GTAlgorithmUtils.ComputeEarliestStartTime (selectedTask, resultingSchedule);
+        double startTime = GTAlgorithmUtils.ComputeEarliestStartTime(selectedTask, resultingSchedule);
         resultingSchedule.ScheduleTask(selectedTask.ResourceNr.Value, startTime, selectedTask.Duration.Value, selectedTask.JobNr.Value);
 
@@ -259,5 +251,5 @@
     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 6364)
+++ branches/Scheduling/HeuristicLab.Problems.Scheduling/3.3/Decoders/PWRDecoder.cs	(revision 6406)
@@ -20,22 +20,23 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
+using HeuristicLab.Encodings.ScheduleEncoding;
+using HeuristicLab.Encodings.ScheduleEncoding.PermutationWithRepetition;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SchedulingEncoding;
-using HeuristicLab.Encodings.SchedulingEncoding.PermutationWithRepetition;
-using HeuristicLab.Problems.Scheduling.Interfaces;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Problems.Scheduling.Decoders {
+namespace HeuristicLab.Problems.Scheduling {
   [Item("PWRDecoder", "An item used to convert a PWR-individual into a generalized schedule.")]
   [StorableClass]
-  public class PWRDecoder : SchedulingDecoder<PWREncoding>, IStochasticOperator, IJSSPOperator {
+  public class PWRDecoder : ScheduleDecoder<PWREncoding>, IStochasticOperator, IJSSPOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemList<Job>> JobDataParameter {
+      get { return (LookupParameter<ItemList<Job>>)Parameters["JobData"]; }
+    }
+
     [StorableConstructor]
     protected PWRDecoder(bool deserializing) : base(deserializing) { }
@@ -47,27 +48,21 @@
     }
 
-    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."));
+      ScheduleEncodingParameter.ActualName = "PermutationWithRepetition";
     }
 
     public override Schedule CreateScheduleFromEncoding(PWREncoding solution) {
       ItemList<Job> jobs = (ItemList<Job>)JobDataParameter.ActualValue.Clone();
-      Schedule resultingSchedule = new Schedule(new IntValue(jobs[0].Tasks.Count));
+      Schedule resultingSchedule = new Schedule(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);
+        double startTime = GTAlgorithmUtils.ComputeEarliestStartTime(currentTask, resultingSchedule);
         currentTask.IsScheduled.Value = true;
-        resultingSchedule.ScheduleTask(currentTask.ResourceNr.Value,startTime, currentTask.Duration.Value, currentTask.JobNr.Value);
+        resultingSchedule.ScheduleTask(currentTask.ResourceNr.Value, startTime, currentTask.Duration.Value, currentTask.JobNr.Value);
       }
       return resultingSchedule;
@@ -76,5 +71,5 @@
     public override IOperation Apply() {
       return base.Apply();
-    } 
+    }
   }
 }
