10 files changed, 1133 insertions, 0 deletions

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/AlwaysSatisfiedDummyHardObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/AlwaysSatisfiedDummyHardObjective.java
new file mode 100644
index 00000000..9898a3b5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/AlwaysSatisfiedDummyHardObjective.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, 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.objectives.impl;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+
+/**
+ * This hard objective is fulfilled in any circumstances. Use it if all states should be regarded as a valid solution.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class AlwaysSatisfiedDummyHardObjective extends BaseObjective {
+
+    private static final String DEFAULT_NAME = "AlwaysSatisfiedDummyHardObjective";
+
+    public AlwaysSatisfiedDummyHardObjective() {
+        super(DEFAULT_NAME);
+    }
+
+    public AlwaysSatisfiedDummyHardObjective(String name) {
+        super(name);
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+        return 0d;
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return true;
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+        return true;
+    }
+
+    @Override
+    public IObjective createNew() {
+        return this;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/BaseObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/BaseObjective.java
new file mode 100644
index 00000000..0a1de875
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/BaseObjective.java
@@ -0,0 +1,150 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, 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.objectives.impl;
+
+import java.util.Comparator;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.Comparators;
+import org.eclipse.viatra.dse.objectives.IObjective;
+
+/**
+ * This abstract class implements the basic functionality of an objective ({@link IObjective} namely its name,
+ * comparator, level and fitness hard constraint.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public abstract class BaseObjective implements IObjective {
+
+    protected final String name;
+    protected Comparator<Double> comparator = Comparators.HIGHER_IS_BETTER;
+    protected int level = 0;
+
+    protected double fitnessConstraint;
+    protected boolean isThereFitnessConstraint = false;
+    protected Comparator<Double> fitnessConstraintComparator;
+
+    public BaseObjective(String name) {
+        Objects.requireNonNull(name, "Name of the objective cannot be null.");
+        this.name = name;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public void setComparator(Comparator<Double> comparator) {
+        this.comparator = comparator;
+    }
+
+    @Override
+    public Comparator<Double> getComparator() {
+        return comparator;
+    }
+
+    @Override
+    public void setLevel(int level) {
+        this.level = level;
+    }
+
+    @Override
+    public int getLevel() {
+        return level;
+    }
+
+    public BaseObjective withLevel(int level) {
+        setLevel(level);
+        return this;
+    }
+
+    public BaseObjective withComparator(Comparator<Double> comparator) {
+        setComparator(comparator);
+        return this;
+    }
+
+    /**
+     * Adds a hard constraint on the fitness value. For example, the fitness value must be better than 10 to accept the
+     * current state as a solution.
+     * 
+     * @param fitnessConstraint
+     *            Solutions should be better than this value.
+     * @param fitnessConstraintComparator
+     *            {@link Comparator} to determine if the current state is better than the given value.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public BaseObjective withHardConstraintOnFitness(double fitnessConstraint,
+            Comparator<Double> fitnessConstraintComparator) {
+        this.fitnessConstraint = fitnessConstraint;
+        this.fitnessConstraintComparator = fitnessConstraintComparator;
+        this.isThereFitnessConstraint = true;
+        return this;
+    }
+
+    /**
+     * Adds a hard constraint on the fitness value. For example, the fitness value must be better than 10 to accept the
+     * current state as a solution. The provided comparator will be used.
+     * 
+     * @param fitnessConstraint
+     *            Solutions should be better than this value.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public BaseObjective withHardConstraintOnFitness(double fitnessConstraint) {
+        return withHardConstraintOnFitness(fitnessConstraint, null);
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        if (fitnessConstraintComparator == null) {
+            fitnessConstraintComparator = comparator;
+        }   
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return isThereFitnessConstraint;
+    }
+    
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+        if (isThereFitnessConstraint) {
+            int compare = fitnessConstraintComparator.compare(fitness, fitnessConstraint);
+            if (compare < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    @Override
+    public int hashCode() {
+        return name.hashCode();
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof BaseObjective) {
+            BaseObjective baseObjective = (BaseObjective) obj;
+            return name.equals(baseObjective.getName());
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/CompositeObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/CompositeObjective.java
new file mode 100644
index 00000000..cc48d22e
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/CompositeObjective.java
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ * 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.objectives.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;
+
+/**
+ * This objective collects a list of other objectives. It returns the weighted sum of the objectives.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class CompositeObjective extends BaseObjective {
+
+    public static final String DEFAULT_NAME = "CompositeObjective";
+    protected List<IObjective> objectives;
+    protected List<Double> weights;
+    protected boolean hardObjective;
+
+    public CompositeObjective(String name, List<IObjective> objectives, List<Double> weights) {
+        super(name);
+        Objects.requireNonNull(objectives, "The list of objectives cannot be null.");
+        Objects.requireNonNull(weights, "The list of weights cannot be null.");
+        Preconditions.checkState(objectives.size() == weights.size(), "The size of the objectives and weights must match.");
+        this.objectives = objectives;
+        this.weights = weights;
+    }
+
+    public CompositeObjective(List<IObjective> objectives, List<Double> weights) {
+        this(DEFAULT_NAME, objectives, weights);
+    }
+
+    public CompositeObjective(String name) {
+        this(name, new ArrayList<IObjective>(), new ArrayList<Double>());
+    }
+
+    public CompositeObjective() {
+        this(DEFAULT_NAME, new ArrayList<IObjective>(), new ArrayList<Double>());
+    }
+
+    /**
+     * Adds a new objective.
+     * 
+     * @param objective
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public CompositeObjective withObjective(IObjective objective) {
+        objectives.add(objective);
+        weights.add(1d);
+        return this;
+    }
+
+    /**
+     * Adds a new objective.
+     * 
+     * @param objective
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public CompositeObjective withObjective(IObjective objective, double weight) {
+        objectives.add(objective);
+        weights.add(weight);
+        return this;
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+
+        double result = 0;
+
+        for (int i = 0; i < objectives.size(); i++) {
+            IObjective objective = objectives.get(i);
+            Double weight = weights.get(i);
+            result += objective.getFitness(context) * weight;
+        }
+        return result;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        super.init(context);
+        hardObjective = false;
+        for (IObjective objective : objectives) {
+            objective.init(context);
+            if (objective.isHardObjective()) {
+                hardObjective = true;
+            }
+        }
+    }
+
+    @Override
+    public IObjective createNew() {
+
+        List<IObjective> newObjectives = new ArrayList<IObjective>();
+
+        for (IObjective objective : objectives) {
+            newObjectives.add(objective.createNew());
+        }
+
+        CompositeObjective objective = new CompositeObjective(name, newObjectives, weights);
+        if (isThereFitnessConstraint) {
+            objective.withHardConstraintOnFitness(fitnessConstraint, fitnessConstraintComparator);
+        }
+
+        return objective.withComparator(comparator).withLevel(level);
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return hardObjective;
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+
+        boolean hardObjectiveSatisfied = true;
+
+        for (IObjective objective : objectives) {
+            hardObjectiveSatisfied = objective.satisifiesHardObjective(fitness) ? hardObjectiveSatisfied : false;
+        }
+
+        hardObjectiveSatisfied = super.satisifiesHardObjective(fitness) ? hardObjectiveSatisfied : false;
+
+        return hardObjectiveSatisfied;
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ConstraintsObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ConstraintsObjective.java
new file mode 100644
index 00000000..77d416f5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ConstraintsObjective.java
@@ -0,0 +1,316 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, 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.objectives.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+import org.eclipse.viatra.query.runtime.exception.ViatraQueryException;
+
+/**
+ * This objective serves as soft and as hard objective at the same time by defining two lists of VIATRA Query
+ * specifications.
+ * 
+ * As a soft objective, it collects a list of VIATRA Query specifications, which have predefined weights. Then the
+ * fitness value of an arbitrary solution is calculated in the following way:
+ * <p>
+ * <code>fitness = sum( pattern[i].countMatches() * weight[i] )</code>
+ * <p>
+ * As a hard objective it collects a separate list of VIATRA Query specifications. If every one of them has a match the
+ * hard constraint is considered to be fulfilled.
+ * 
+ * @author Andras Szabolcs Nagy
+ * @see IObjective
+ *
+ */
+public class ConstraintsObjective extends BaseObjective {
+
+    public static final String DEFAULT_NAME = "ConstraintsObjective";
+
+    public static class QueryConstraint {
+        public final String name;
+        public final IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> query;
+        public final Double weight;
+        public final ModelQueryType type;
+
+        public QueryConstraint(String name,
+                IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> query, Double weight,
+                ModelQueryType type) {
+            this.name = name;
+            this.query = query;
+            this.weight = weight;
+            this.type = type;
+        }
+
+        public QueryConstraint(String name,
+                IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> query, Double weight) {
+            this(name, query, weight, ModelQueryType.MUST_HAVE_MATCH);
+        }
+
+        public QueryConstraint(String name,
+                IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> query, ModelQueryType type) {
+            this(name, query, 0d, type);
+        }
+    }
+
+    protected List<QueryConstraint> softConstraints;
+    protected List<QueryConstraint> hardConstraints;
+
+    protected List<ViatraQueryMatcher<? extends IPatternMatch>> softMatchers;
+    protected List<ViatraQueryMatcher<? extends IPatternMatch>> hardMatchers;
+    protected List<Integer> softMatches;
+    protected List<Integer> hardMatches;
+
+    public ConstraintsObjective(String name, List<QueryConstraint> softConstraints,
+            List<QueryConstraint> hardConstraints) {
+        super(name);
+        Objects.requireNonNull(softConstraints, "The list of soft constraints cannot be null.");
+        Objects.requireNonNull(hardConstraints, "The list of hard constraints cannot be null.");
+
+        this.softConstraints = softConstraints;
+        this.hardConstraints = hardConstraints;
+    }
+
+    public ConstraintsObjective(String name, List<QueryConstraint> hardConstraints) {
+        this(name, new ArrayList<QueryConstraint>(), hardConstraints);
+    }
+
+    public ConstraintsObjective(List<QueryConstraint> hardConstraints) {
+        this(DEFAULT_NAME, new ArrayList<QueryConstraint>(), hardConstraints);
+    }
+
+    public ConstraintsObjective(String name) {
+        this(name, new ArrayList<QueryConstraint>(), new ArrayList<QueryConstraint>());
+    }
+
+    public ConstraintsObjective() {
+        this(DEFAULT_NAME, new ArrayList<QueryConstraint>(), new ArrayList<QueryConstraint>());
+    }
+
+    /**
+     * Adds a new soft constraint.
+     * 
+     * @param name
+     *            A name for the soft constraint.
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @param weight
+     *            The weight of the pattern.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withSoftConstraint(String name,
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> softConstraint, double weight) {
+        softConstraints.add(new QueryConstraint(name, softConstraint, weight));
+        return this;
+    }
+
+    /**
+     * Adds a new soft constraint with the name of the query specification's fully qualified name.
+     * 
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @param weight
+     *            The weight of the pattern.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withSoftConstraint(
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> softConstraint, double weight) {
+        return withSoftConstraint(softConstraint.getFullyQualifiedName(), softConstraint, weight);
+    }
+
+    /**
+     * Adds a new hard constraint.
+     * 
+     * @param name
+     *            A name for the hard constraint.
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @param type
+     *            {@link ModelQueryType}, which determines whether the constraint should have at least one match or none
+     *            at all.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withHardConstraint(String name,
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hardConstraint,
+            ModelQueryType type) {
+        hardConstraints.add(new QueryConstraint(name, hardConstraint, type));
+        return this;
+    }
+
+    /**
+     * Adds a new hard constraint with the default {@link ModelQueryType#MUST_HAVE_MATCH}.
+     * 
+     * @param name
+     *            A name for the hard constraint.
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withHardConstraint(String name,
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hardConstraint) {
+        hardConstraints.add(new QueryConstraint(name, hardConstraint, ModelQueryType.MUST_HAVE_MATCH));
+        return this;
+    }
+
+    /**
+     * Adds a new hard constraint with the name of the query specification's fully qualified name and the default
+     * {@link ModelQueryType#MUST_HAVE_MATCH}.
+     * 
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withHardConstraint(
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hardConstraint) {
+        return withHardConstraint(hardConstraint.getFullyQualifiedName(), hardConstraint,
+                ModelQueryType.MUST_HAVE_MATCH);
+    }
+
+    /**
+     * Adds a new hard constraint with the name of the query specification's fully qualified name.
+     * 
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @param type
+     *            {@link ModelQueryType}, which determines whether the constraint should have at least one match or none
+     *            at all.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withHardConstraint(
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hardConstraint,
+            ModelQueryType type) {
+        return withHardConstraint(hardConstraint.getFullyQualifiedName(), hardConstraint, type);
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+
+        if (softConstraints.isEmpty()) {
+            return 0d;
+        }
+
+        double result = 0;
+
+        for (int i = 0; i < softConstraints.size(); i++) {
+            int countMatches = softMatchers.get(i).countMatches();
+            result += countMatches * softConstraints.get(i).weight;
+            softMatches.set(i, Integer.valueOf(countMatches));
+        }
+
+        return result;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+
+        super.init(context);
+
+        softMatches = new ArrayList<Integer>(softConstraints.size());
+        softMatchers = new ArrayList<ViatraQueryMatcher<? extends IPatternMatch>>(softConstraints.size());
+        hardMatches = new ArrayList<Integer>(hardConstraints.size());
+        hardMatchers = new ArrayList<ViatraQueryMatcher<? extends IPatternMatch>>(hardConstraints.size());
+        for (int i = 0; i < softConstraints.size(); i++) {
+            softMatches.add(0);
+        }
+        for (int i = 0; i < hardConstraints.size(); i++) {
+            hardMatches.add(0);
+        }
+
+        try {
+            ViatraQueryEngine queryEngine = context.getQueryEngine();
+
+            for (QueryConstraint qc : softConstraints) {
+                softMatchers.add(qc.query.getMatcher(queryEngine));
+            }
+
+            for (QueryConstraint qc : hardConstraints) {
+                hardMatchers.add(qc.query.getMatcher(queryEngine));
+            }
+
+        } catch (ViatraQueryException e) {
+            throw new DSEException("Couldn't initialize the VIATRA Query matcher, see inner exception", e);
+        }
+    }
+
+    @Override
+    public IObjective createNew() {
+        new ArrayList<Double>(softConstraints.size());
+        ConstraintsObjective result = new ConstraintsObjective(name, softConstraints, hardConstraints);
+        if (isThereFitnessConstraint) {
+            result.withHardConstraintOnFitness(fitnessConstraint, fitnessConstraintComparator);
+        }
+        return result.withComparator(comparator).withLevel(level);
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return !hardConstraints.isEmpty() || super.isHardObjective();
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+
+        boolean result = true;
+
+        for (int i = 0; i < hardConstraints.size(); i++) {
+            ModelQueryType type = hardConstraints.get(i).type;
+            int countMatches = hardMatchers.get(i).countMatches();
+            hardMatches.set(i, Integer.valueOf(countMatches));
+            if ((type.equals(ModelQueryType.MUST_HAVE_MATCH) && countMatches <= 0)
+                    || (type.equals(ModelQueryType.NO_MATCH) && countMatches > 0)) {
+                result = false;
+            }
+        }
+        
+        result = super.satisifiesHardObjective(fitness) ? result : false;
+        
+        return result;
+    }
+
+    public List<QueryConstraint> getSoftConstraints() {
+        return softConstraints;
+    }
+
+    public List<QueryConstraint> getHardConstraints() {
+        return hardConstraints;
+    }
+
+    public String getSoftName(int index) {
+        return softConstraints.get(index).name;
+    }
+
+    public String getHardName(int index) {
+        return hardConstraints.get(index).name;
+    }
+
+    public List<Integer> getSoftMatches() {
+        return softMatches;
+    }
+
+    public List<Integer> getHardMatches() {
+        return hardMatches;
+    }
+
+    public List<String> getSoftNames() {
+        List<String> softNames = new ArrayList<>(softConstraints.size());
+        for (QueryConstraint qc : softConstraints) {
+            softNames.add(qc.name);
+        }
+        return softNames;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/DepthHardObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/DepthHardObjective.java
new file mode 100644
index 00000000..b21da397
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/DepthHardObjective.java
@@ -0,0 +1,89 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, 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.objectives.impl;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+
+/**
+ * This hard objective is fulfilled if the trajectory is in the specified interval (inclusive).
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class DepthHardObjective extends BaseObjective {
+
+    private static final String DEFAULT_NAME = "DepthHardObjective";
+    protected int minDepth;
+    protected int maxDepth;
+    private ThreadContext context;
+
+    public DepthHardObjective() {
+        this(DEFAULT_NAME, 0, Integer.MAX_VALUE);
+    }
+
+    public DepthHardObjective(String name) {
+        this(name, 0, Integer.MAX_VALUE);
+    }
+
+    public DepthHardObjective(int minDepth) {
+        this(DEFAULT_NAME, minDepth, Integer.MAX_VALUE);
+    }
+
+    public DepthHardObjective(String name, int minDepth) {
+        this(name, minDepth, Integer.MAX_VALUE);
+    }
+
+    public DepthHardObjective(int minDepth, int maxDepth) {
+        this(DEFAULT_NAME, minDepth, maxDepth);
+    }
+    
+    public DepthHardObjective(String name, int minDepth, int maxDepth) {
+        super(name);
+        this.minDepth = minDepth;
+        this.maxDepth = maxDepth;
+    }
+
+    public DepthHardObjective withMinDepth(int minDepth) {
+        this.minDepth = minDepth;
+        return this;
+    }
+
+    public DepthHardObjective withMaxDepth(int maxDepth) {
+        this.maxDepth = maxDepth;
+        return this;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        super.init(context);
+        this.context = context;
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+        return 0d;
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return true;
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+        return minDepth <= context.getDepth() && context.getDepth() <= maxDepth;
+    }
+
+    @Override
+    public IObjective createNew() {
+        return new DepthHardObjective(name, minDepth, maxDepth);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueriesGlobalConstraint.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueriesGlobalConstraint.java
new file mode 100644
index 00000000..7616b4a2
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueriesGlobalConstraint.java
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * 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.objectives.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+import org.eclipse.viatra.query.runtime.exception.ViatraQueryException;
+
+/**
+ * This global constraint collects a list of VIATRA Query pattern and checks if any of them has a match on along a trajectory.
+ * If any of the patterns has a match then it is unsatisfied and the exploration should backtrack.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class ModelQueriesGlobalConstraint implements IGlobalConstraint {
+
+    public static final String GLOBAL_CONSTRAINT = "GlobalConstraint";
+    protected String name;
+    protected List<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> constraints;
+    protected List<ViatraQueryMatcher<? extends IPatternMatch>> matchers = new ArrayList<ViatraQueryMatcher<? extends IPatternMatch>>();
+    protected ModelQueryType type = ModelQueryType.NO_MATCH;
+
+    public ModelQueriesGlobalConstraint(String name,
+            List<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> constraints) {
+        Objects.requireNonNull(name, "Name of the global constraint cannot be null.");
+        Objects.requireNonNull(constraints, "The list of constraints cannot be null.");
+
+        this.name = name;
+        this.constraints = constraints;
+    }
+
+    public ModelQueriesGlobalConstraint(
+            List<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> constraints) {
+        this(GLOBAL_CONSTRAINT, constraints);
+    }
+
+    public ModelQueriesGlobalConstraint(String name) {
+        this(name, new ArrayList<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>());
+    }
+
+    public ModelQueriesGlobalConstraint() {
+        this(GLOBAL_CONSTRAINT,
+                new ArrayList<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>());
+    }
+
+    /**
+     * Adds a new VIATRA Query pattern.
+     * 
+     * @param constraint
+     *            A VIATRA Query pattern.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ModelQueriesGlobalConstraint withConstraint(
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> constraint) {
+        constraints.add(constraint);
+        return this;
+    }
+
+    public ModelQueriesGlobalConstraint withType(ModelQueryType type) {
+        this.type = type;
+        return this;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public boolean checkGlobalConstraint(ThreadContext context) {
+        for (ViatraQueryMatcher<? extends IPatternMatch> matcher : matchers) {
+            if ((type.equals(ModelQueryType.NO_MATCH) && matcher.countMatches() > 0)
+                    || (type.equals(ModelQueryType.MUST_HAVE_MATCH) && matcher.countMatches() == 0)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        try {
+            ViatraQueryEngine queryEngine = context.getQueryEngine();
+
+            for (IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification : constraints) {
+                ViatraQueryMatcher<? extends IPatternMatch> matcher = querySpecification.getMatcher(queryEngine);
+                matchers.add(matcher);
+            }
+
+        } catch (ViatraQueryException e) {
+        throw new DSEException("Couldn't get the VIATRA Query matcher, see inner exception", e);
+        }
+    }
+
+    @Override
+    public IGlobalConstraint createNew() {
+        return new ModelQueriesGlobalConstraint(name, constraints);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueryType.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueryType.java
new file mode 100644
index 00000000..76390352
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueryType.java
@@ -0,0 +1,14 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, 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.objectives.impl;
+
+public enum ModelQueryType {
+    MUST_HAVE_MATCH,
+    NO_MATCH
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NeverSatisfiedDummyHardObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NeverSatisfiedDummyHardObjective.java
new file mode 100644
index 00000000..27cf139c
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NeverSatisfiedDummyHardObjective.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, 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.objectives.impl;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+
+/**
+ * This hard objective is never fulfilled. Use it if all states should be regarded as an invalid solution.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class NeverSatisfiedDummyHardObjective extends BaseObjective {
+
+    private static final String DEFAULT_NAME = "NeverSatisfiedDummyHardObjective";
+
+    public NeverSatisfiedDummyHardObjective() {
+        super(DEFAULT_NAME);
+    }
+
+    public NeverSatisfiedDummyHardObjective(String name) {
+        super(name);
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+        return 0d;
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return true;
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+        return false;
+    }
+
+    @Override
+    public IObjective createNew() {
+        return this;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NoRuleActivationsHardObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NoRuleActivationsHardObjective.java
new file mode 100644
index 00000000..756d94ec
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NoRuleActivationsHardObjective.java
@@ -0,0 +1,59 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, 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.objectives.impl;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+
+/**
+ * This hard objective is satisfied if there are no rule activations from the current state (returning 1 in this case).
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class NoRuleActivationsHardObjective extends BaseObjective {
+
+    protected static final String DEFAULT_NAME = "NoMoreActivationHardObjective";
+    private ThreadContext context;
+
+    public NoRuleActivationsHardObjective(String name) {
+        super(name);
+    }
+
+    public NoRuleActivationsHardObjective() {
+        this(DEFAULT_NAME);
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+        return 0d;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        super.init(context);
+        this.context = context;
+    }
+
+    @Override
+    public IObjective createNew() {
+        return new NoRuleActivationsHardObjective(name);
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return true;
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+        return context.getConflictSet().getNextActivations().isEmpty();
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/TrajectoryCostSoftObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/TrajectoryCostSoftObjective.java
new file mode 100644
index 00000000..25ff45ae
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/TrajectoryCostSoftObjective.java
@@ -0,0 +1,148 @@
+/*******************************************************************************
+ * 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.objectives.impl;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.base.DesignSpaceManager;
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.designspace.api.TrajectoryInfo;
+import org.eclipse.viatra.dse.objectives.ActivationFitnessProcessor;
+import org.eclipse.viatra.dse.objectives.Comparators;
+import org.eclipse.viatra.dse.objectives.IObjective;
+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+/**
+ * This soft objective calculates a fitness value based on the length of the trajectory. Costs to the rules can be
+ * assigned.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class TrajectoryCostSoftObjective extends BaseObjective {
+
+    public static final String DEFAULT_NAME = "TrajectoryCostObjective";
+    protected Map<BatchTransformationRule<?, ?>, Double> fixCosts;
+    protected Map<BatchTransformationRule<?, ?>, ActivationFitnessProcessor> activationCostProcessors;
+    protected double trajectoryLengthWeight = 0.0;
+    protected boolean calculateTrajectoryLengthWeight;
+
+    public TrajectoryCostSoftObjective(String name) {
+        super(name);
+        comparator = Comparators.LOWER_IS_BETTER;
+    }
+
+    public TrajectoryCostSoftObjective() {
+        this(DEFAULT_NAME);
+    }
+
+    /**
+     * Sets the cost of a rule.
+     * 
+     * @param rule
+     * @param cost
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public TrajectoryCostSoftObjective withRuleCost(BatchTransformationRule<?, ?> rule, double cost) {
+        Objects.requireNonNull(rule);
+        if (fixCosts == null) {
+            fixCosts = new HashMap<BatchTransformationRule<?, ?>, Double>();
+        }
+        Preconditions.checkArgument(!fixCosts.containsKey(rule));
+        fixCosts.put(rule, cost);
+        return this;
+    }
+
+    /**
+     * Sets an activation processor for a rule.
+     * 
+     * @param rule
+     * @param activationCostProcessor
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public TrajectoryCostSoftObjective withActivationCost(BatchTransformationRule<?, ?> rule,
+            ActivationFitnessProcessor activationCostProcessor) {
+        Objects.requireNonNull(rule);
+        Objects.requireNonNull(activationCostProcessor);
+        if (activationCostProcessors == null) {
+            activationCostProcessors = new HashMap<BatchTransformationRule<?, ?>, ActivationFitnessProcessor>();
+        }
+        Preconditions.checkArgument(!activationCostProcessors.containsKey(rule));
+        activationCostProcessors.put(rule, activationCostProcessor);
+        return this;
+    }
+
+    /**
+     * The length of the trajectory multiplied with given parameter will be added to the fitness value.
+     * 
+     * @param trajectoryLengthWeight
+     *            The weight of a transformation rule application.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public TrajectoryCostSoftObjective withTrajectoryLengthWeight(double trajectoryLengthWeight) {
+        this.trajectoryLengthWeight = trajectoryLengthWeight;
+        this.calculateTrajectoryLengthWeight = true;
+        return this;
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+
+        DesignSpaceManager dsm = context.getDesignSpaceManager();
+        TrajectoryInfo trajectoryInfo = dsm.getTrajectoryInfo();
+        List<Object> trajectory = trajectoryInfo.getTrajectory();
+        List<BatchTransformationRule<?, ?>> rules = trajectoryInfo.getRules();
+
+        double result = 0;
+
+        for (int i = 0; i < trajectory.size(); i++) {
+            BatchTransformationRule<?, ?> rule = rules.get(i);
+
+            Double cost = fixCosts.get(rule);
+            if (cost != null) {
+                result += cost;
+            }
+
+            Map<String, Double> costs = trajectoryInfo.getMeasuredCosts().get(i);
+            if (costs != null) {
+                cost = costs.get(name);
+                if (cost != null) {
+                    result += cost;
+                }
+            }
+        }
+
+        if (calculateTrajectoryLengthWeight) {
+            result += trajectory.size() * trajectoryLengthWeight;
+        }
+
+        return result;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        super.init(context);
+        DesignSpaceManager dsm = context.getDesignSpaceManager();
+        if (activationCostProcessors != null) {
+            for (Entry<BatchTransformationRule<?, ?>, ActivationFitnessProcessor> entry : activationCostProcessors.entrySet()) {
+                dsm.registerActivationCostProcessor(name, entry.getKey(), entry.getValue());
+            }
+        }
+    }
+
+    @Override
+    public IObjective createNew() {
+        return this;
+    }
+}