4 files changed, 294 insertions, 0 deletions

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/DesignSpace.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/DesignSpace.java
new file mode 100644
index 00000000..bc0f08d4
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/DesignSpace.java
@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.designspace.api;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+
+public class DesignSpace implements IDesignSpace {
+
+    Set<Object> statesView;
+
+    Set<Object> rootStates;
+    Set<Object> rootStatesView;
+
+    Map<Object, List<Object>> statesAndActivations;
+
+    Random random = new Random();
+
+    public DesignSpace() {
+        rootStates = new HashSet<>();
+        rootStatesView = Collections.unmodifiableSet(rootStates);
+
+        statesAndActivations = new HashMap<>();
+        statesView = statesAndActivations.keySet();
+    }
+
+    @Override
+    public synchronized Collection<Object> getStates() {
+        return statesView;
+    }
+
+    @Override
+    public synchronized Collection<Object> getRoots() {
+        return rootStatesView;
+    }
+
+    @Override
+    public synchronized void addState(Object sourceStateId, Object firedActivationId, Object newStateId) {
+
+        List<Object> activationIds = statesAndActivations.get(newStateId);
+
+        if (activationIds == null) {
+            activationIds = new ArrayList<Object>();
+            statesAndActivations.put(newStateId, activationIds);
+
+            if (sourceStateId == null) {
+                rootStates.add(newStateId);
+                return;
+            }
+        }
+
+        activationIds = statesAndActivations.get(sourceStateId);
+
+        if (activationIds == null) {
+            activationIds = new ArrayList<Object>();
+            activationIds.add(firedActivationId);
+            statesAndActivations.put(sourceStateId, activationIds);
+        } else {
+            activationIds.add(firedActivationId);
+        }
+    }
+
+    public synchronized boolean isTraversed(Object stateId) {
+        return statesAndActivations.containsKey(stateId);
+    }
+
+    @Override
+    public synchronized Collection<Object> getActivationIds(Object stateId) {
+        return statesAndActivations.get(stateId);
+    }
+
+    @Override
+    public synchronized Object getRandomActivationId(Object stateId) {
+        List<Object> activations = statesAndActivations.get(stateId);
+        int index = random.nextInt(activations.size());
+        return activations.get(index);
+    }
+
+    @Override
+    public synchronized long getNumberOfStates() {
+        return statesAndActivations.size();
+    }
+
+    @Override
+    public synchronized long getNumberOfTransitions() {
+        int numberOfTransitions = 0;
+        for (List<Object> activations : statesAndActivations.values()) {
+            numberOfTransitions += activations.size();
+        }
+        return numberOfTransitions;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IBacktrackListener.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IBacktrackListener.java
new file mode 100644
index 00000000..5c688276
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IBacktrackListener.java
@@ -0,0 +1,7 @@
+package org.eclipse.viatra.dse.designspace.api;
+
+public interface IBacktrackListener {
+        void forwardWorked(long nanos);
+        
+        void backtrackWorked(long nanos);
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IDesignSpace.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IDesignSpace.java
new file mode 100644
index 00000000..a1d64bbf
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IDesignSpace.java
@@ -0,0 +1,27 @@
+/*******************************************************************************

+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy and Daniel Varro

+ * This program and the accompanying materials are made available under the

+ * terms of the Eclipse Public License v. 2.0 which is available at

+ * http://www.eclipse.org/legal/epl-v20.html.

+ * 

+ * SPDX-License-Identifier: EPL-2.0

+ *******************************************************************************/

+package org.eclipse.viatra.dse.designspace.api;

+

+import java.util.Collection;

+

+public interface IDesignSpace {

+

+    Collection<Object> getStates();

+    Collection<Object> getRoots();

+    void addState(Object sourceStateId, Object firedActivationId, Object newStateId);

+

+    boolean isTraversed(Object stateId);

+

+    Collection<Object> getActivationIds(Object stateId);

+    Object getRandomActivationId(Object stateId);

+

+    long getNumberOfStates();

+    long getNumberOfTransitions();

+

+}

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/TrajectoryInfo.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/TrajectoryInfo.java
new file mode 100644
index 00000000..acd88416
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/TrajectoryInfo.java
@@ -0,0 +1,154 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.designspace.api;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.api.SolutionTrajectory;
+import org.eclipse.viatra.dse.base.DesignSpaceManager;
+import org.eclipse.viatra.dse.statecode.IStateCoderFactory;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+public class TrajectoryInfo {
+
+    private final List<Object> trajectory;
+    private final List<Object> trajectoryView;
+    private final List<BatchTransformationRule<?, ?>> rules;
+    private final List<BatchTransformationRule<?, ?>> rulesView;
+    private final List<Object> stateIds;
+    private final List<Object> stateIdsView;
+    private final List<Map<String, Double>> measuredCosts;
+
+    public TrajectoryInfo(Object initialStateId) {
+        Objects.requireNonNull(initialStateId);
+
+        stateIds = new ArrayList<>();
+        stateIds.add(initialStateId);
+
+        trajectory = new ArrayList<>();
+        rules = new ArrayList<>();
+        measuredCosts = new ArrayList<>();
+
+        trajectoryView = Collections.unmodifiableList(trajectory);
+        stateIdsView = Collections.unmodifiableList(stateIds);
+        rulesView = Collections.unmodifiableList(rules);
+    }
+
+    /**
+     * Copy constructor
+     * 
+     * @since 0.17
+     */
+    public TrajectoryInfo(TrajectoryInfo other) {
+        this(other.stateIds, other.trajectory, other.rules, other.measuredCosts);
+    }
+    
+    protected TrajectoryInfo(List<Object> stateIds, List<Object> trajectory, List<BatchTransformationRule<?, ?>> rules, List<Map<String, Double>> measuredCosts) {
+
+        this.stateIds = new ArrayList<>(stateIds);
+        this.trajectory = new ArrayList<>(trajectory);
+        this.rules = new ArrayList<>(rules);
+        trajectoryView = Collections.unmodifiableList(trajectory);
+        stateIdsView = Collections.unmodifiableList(stateIds);
+        rulesView = Collections.unmodifiableList(rules);
+        this.measuredCosts = new ArrayList<>(measuredCosts);
+    }
+
+    public void addStep(Object activationId, BatchTransformationRule<?, ?> rule, Object newStateId, Map<String, Double> measuredCosts) {
+        stateIds.add(newStateId);
+        trajectory.add(activationId);
+        rules.add(rule);
+        this.measuredCosts.add(measuredCosts);
+    }
+
+    public void backtrack() {
+        int size = trajectory.size();
+
+        if (size == 0) {
+            throw new DSEException("Cannot step back any further!");
+        }
+
+        trajectory.remove(size - 1);
+        rules.remove(size - 1);
+        stateIds.remove(size);
+        measuredCosts.remove(size - 1);
+    }
+
+    public Object getInitialStateId() {
+        return stateIds.get(0);
+    }
+
+    public Object getCurrentStateId() {
+        return stateIds.get(stateIds.size() - 1);
+    }
+
+    public Object getLastActivationId() {
+        return trajectory.get(trajectory.size() - 1);
+    }
+
+    public List<Object> getTrajectory() {
+        return trajectoryView;
+    }
+
+    public List<Object> getStateTrajectory() {
+        return stateIdsView;
+    }
+
+    public List<BatchTransformationRule<?, ?>> getRules() {
+        return rulesView;
+    }
+
+    public int getDepth() {
+        return trajectory.size();
+    }
+
+    public List<Map<String, Double>> getMeasuredCosts() {
+        return measuredCosts;
+    }
+
+    public SolutionTrajectory createSolutionTrajectory(final IStateCoderFactory stateCoderFactory, final IBacktrackListener listener) {
+
+        List<Object> activationIds = new ArrayList<>(trajectory);
+        List<BatchTransformationRule<?, ?>> copiedRules = new ArrayList<>(rules);
+
+        return new SolutionTrajectory(activationIds, copiedRules, stateCoderFactory, listener);
+    }
+
+    public boolean canStepBack() {
+        return !trajectory.isEmpty();
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("Trajectory:\n");
+        for (Object activationId : trajectory) {
+            sb.append(activationId);
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+    /**
+     * This method is only used by the {@link DesignSpaceManager}.
+     * @param stateCode 
+     * @return false if the initial state code is the last one, otherwise true.
+     */
+    public boolean modifyLastStateCode(Object stateCode) {
+        if (stateIds.size() == 1) {
+            return false;
+        }
+        stateIds.set(stateIds.size() - 1, stateCode);
+        return true;
+    }
+}