Changeset 13351 for branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/MultiSolution.cs

Timestamp:

11/23/15 22:18:35 (8 years ago)

Author:

abeham

Message:

#2521: Adapted multi-encoding for new infrastructure

TODO: Evaluator, Analyzer, ... need to be copied

File:

• branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/MultiSolution.cs (moved) (moved from branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/MultiEncodingIndividual.cs) (1 diff)

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Individuals/MultiSolution.cs

@@ -25 +25 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Optimization {
-  public sealed class MultiEncodingIndividual : Individual {
-    private new MultiEncoding Encoding {
-      get { return (MultiEncoding)base.Encoding; }
+  [Item("MultiSolution", "A solution that consists of other solutions.")]
+  [StorableClass]
+  public sealed class MultiSolution : Item, ISolution {
+
+    private MultiEncoding Encoding { get; set; }
+    protected IScope Scope { get; private set; }
+
+    private readonly Dictionary<string, ISolution> solutions;
+
+    [StorableConstructor]
+    private MultiSolution(bool deserializing) : base(deserializing) { }
+
+    private MultiSolution(MultiSolution original, Cloner cloner)
+      : base(original, cloner) {
+      Encoding = cloner.Clone(original.Encoding);
+      Scope = cloner.Clone(original.Scope);
+      solutions = original.solutions.ToDictionary(x => x.Key, x => cloner.Clone(x.Value));
+    }
+    public MultiSolution(MultiEncoding encoding, IScope scope) {
+      Encoding = encoding;
+      Scope = scope;
+      solutions = encoding.Encodings.Select(e => new { Name = e.Name, Solution = ScopeUtil.GetSolution(scope, e) })
+                                    .ToDictionary(x => x.Name, x => x.Solution);
     }
 
-    private readonly IEnumerable<Individual> individuals;
-
-    public MultiEncodingIndividual(MultiEncoding encoding, IScope scope)
-      : base(encoding, scope) {
-      individuals = encoding.Encodings.Select(e => e.GetIndividual(scope)).ToArray();
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiSolution(this, cloner);
     }
 
-    private MultiEncodingIndividual(MultiEncoding encoding, IScope scope, IEnumerable<Individual> individuals)
-      : base(encoding, scope) {
-      this.individuals = individuals;
-    }
-
-
-    public override IItem this[string name] {
+    public ISolution this[string name] {
       get {
-        var individual = individuals.SingleOrDefault(i => i.Name == name);
-        if (individual == null) throw new ArgumentException(string.Format("{0} is not part of the specified encoding.", name));
-        return individual[name];
+        ISolution result;
+        if (!solutions.TryGetValue(name, out result)) throw new ArgumentException(string.Format("{0} is not part of the specified encoding.", name));
+        return result;
       }
       set {
-        var individual = individuals.SingleOrDefault(i => i.Name == name);
-        if (individual == null) throw new ArgumentException(string.Format("{0} is not part of the specified encoding.", name));
-        individual[name] = value;
+        if (!solutions.ContainsKey(name)) throw new ArgumentException(string.Format("{0} is not part of the specified encoding.", name));
+        solutions[name] = value;
       }
     }
 
-    public override TEncoding GetEncoding<TEncoding>() {
+    public TEncoding GetEncoding<TEncoding>() where TEncoding : IEncoding {
       TEncoding encoding;
       try {
         encoding = (TEncoding)Encoding.Encodings.SingleOrDefault(e => e is TEncoding);
       } catch (InvalidOperationException) {
-        throw new InvalidOperationException(string.Format("The individual uses multiple {0} .", typeof(TEncoding).GetPrettyName()));
+        throw new InvalidOperationException(string.Format("The solution uses multiple {0} .", typeof(TEncoding).GetPrettyName()));
       }
-      if (encoding == null) throw new InvalidOperationException(string.Format("The individual does not use a {0}.", typeof(TEncoding).GetPrettyName()));
+      if (encoding == null) throw new InvalidOperationException(string.Format("The solution does not use a {0}.", typeof(TEncoding).GetPrettyName()));
       return encoding;
     }
 
-    public override Individual CopyToScope(IScope scope) {
-      var copies = individuals.Select(i => i.CopyToScope(scope)).ToArray();
-      return new MultiEncodingIndividual(Encoding, scope, copies);
+    public TSolution GetSolution<TSolution>() where TSolution : class, ISolution {
+      TSolution solution;
+      try {
+        solution = (TSolution)solutions.SingleOrDefault(s => s.Value is TSolution).Value;
+      } catch (InvalidOperationException) {
+        throw new InvalidOperationException(string.Format("The solution uses multiple {0} .", typeof(TSolution).GetPrettyName()));
+      }
+      if (solution == null) throw new InvalidOperationException(string.Format("The solution does not use a {0}.", typeof(TSolution).GetPrettyName()));
+      return solution;
     }
   }