Changeset 11739 for branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/ProblemDefinitionScript.cs

Timestamp:

01/08/15 15:52:05 (9 years ago)

Author:

mkommend

Message:

#2174: Worked on operators and programmable problem base classes and scripts.

Location:

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New

Files:

• . (added)
• Scripts (added)
• Scripts/ProblemDefinitionScript.cs (moved) (moved from branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemScript.cs) (5 diffs)

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/New/Scripts/ProblemDefinitionScript.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -31 +32 @@
   [Item("ProblemDefinitionScript", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
   [StorableClass]
-  public abstract class ProblemScript : Script {
+  public abstract class ProblemDefinitionScript : Script, IProblemDefinition {
     protected bool SuppressEvents { get; set; }
 
@@ -41 +42 @@
 
     [StorableConstructor]
-    protected ProblemScript(bool deserializing) : base(deserializing) { }
-    protected ProblemScript(ProblemScript original, Cloner cloner)
+    protected ProblemDefinitionScript(bool deserializing) : base(deserializing) { }
+    protected ProblemDefinitionScript(ProblemDefinitionScript original, Cloner cloner)
       : base(original, cloner) {
       variableStore = cloner.Clone(original.variableStore);
     }
-    protected ProblemScript() {
+    protected ProblemDefinitionScript() :base(){
       variableStore = new VariableStore();
     }
 
-    private volatile IProblemDefinition instance;
-    private object locker = new object();
-    public IProblemDefinition Instance {
+    IEncoding IProblemDefinition.Encoding {
+      get { return CompiledProblemDefinition != null ? CompiledProblemDefinition.Encoding : null; }
+    }
+    IEnumerable<Individual> IProblemDefinition.GetNeighbors(Individual individual, IRandom random) {
+      return CompiledProblemDefinition.GetNeighbors(individual, random);
+    }
+
+    private readonly object locker = new object();
+    private volatile IProblemDefinition compiledProblemDefinition;
+    protected IProblemDefinition CompiledProblemDefinition {
       get {
-        SuppressEvents = true;
-        try {
-          var oldInstance = instance;
-          var compilationNecessary = false;
-          if (instance == null) {
-            lock (locker) {
-              if (instance == null) {
-                compilationNecessary = true;
-                Compile();
-              }
+          lock (locker) {
+            if (compiledProblemDefinition == null) {
+              Compile();
             }
           }
-          if (compilationNecessary && (oldInstance != null || instance != null))
-            OnInstanceChanged();
-          return instance;
-        } finally {
-          SuppressEvents = false;
-        }
+        return compiledProblemDefinition;
       }
-      protected set {
-        instance = value;
-        if (!SuppressEvents) OnInstanceChanged();
+      private set {
+        compiledProblemDefinition = value;
+        OnProblemDefinitionChanged();
       }
     }
@@ -83 +79 @@
       var types = assembly.GetTypes();
       try {
-        var inst = (ProblemScriptBase)Activator.CreateInstance(types.First(x => typeof(ProblemScriptBase).IsAssignableFrom(x)));
+        var inst = (CompiledProblemDefinition)Activator.CreateInstance(types.First(x => typeof(CompiledProblemDefinition).IsAssignableFrom(x)));
         inst.vars = new Variables(VariableStore);
         inst.Initialize();
-        Instance = inst;
-      } catch {
-        Instance = null;
+        CompiledProblemDefinition = inst;
+      }
+      catch {
+        compiledProblemDefinition = null;
       }
       return assembly;
@@ -95 +92 @@
     protected override void OnCodeChanged() {
       base.OnCodeChanged();
-      instance = null;
+      compiledProblemDefinition = null;
     }
 
-    public event EventHandler InstanceChanged;
-    protected virtual void OnInstanceChanged() {
-      var handler = InstanceChanged;
+    public event EventHandler ProblemDefinitionChanged;
+    protected virtual void OnProblemDefinitionChanged() {
+      var handler = ProblemDefinitionChanged;
       if (handler != null) handler(this, EventArgs.Empty);
     }