RateMonotonic.java

package mvd.jester.priority;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import mvd.jester.model.Task;
import mvd.jester.simulator.AbstractSimulator;
import mvd.jester.simulator.internals.TaskContextInterface;
import mvd.jester.tests.AbstractTest;

public class RateMonotonic implements PriorityManager {

    final static Set<Class<? extends AbstractTest<? extends Task>>> abstractTests =
            new HashSet<>(Arrays.asList(mvd.jester.tests.MaiaBertogna.class,
                    mvd.jester.tests.SchmidMottok.class));
    final static Set<Class<? extends AbstractSimulator>> abstractSimulators =
            new HashSet<>(Arrays.asList(mvd.jester.simulator.ParallelSynchronous.class,
                    mvd.jester.simulator.DynamicForkJoin.class));

    /**
     * Compare the priority of two tasks according to the Rate Monotonic policy
     * 
     * @param t1 The first task
     * @param t2 The second task
     * @return 0 if both tasks have the same priority, negative number if the first task has a
     *         higher priority, positive number if the second task has a higher priority
     */
    @Override
    public int compare(Task t1, Task t2) {
        return Long.compare(t1.getPeriod(), t2.getPeriod());
    }

    @Override
    public int compare(TaskContextInterface t1, TaskContextInterface t2) {
        return Long.compare(t1.getTask().getPeriod(), t2.getTask().getPeriod());
    }

    @Override
    public boolean hasTest(AbstractTest<? extends Task> abstractTest) {
        return abstractTests.contains(abstractTest.getClass());
    }

    @Override
    public boolean hasTest(Class<? extends AbstractTest<? extends Task>> abstractTestClass) {
        return abstractTests.contains(abstractTestClass);
    }

    @Override
    public boolean hasSimulator(AbstractSimulator abstractSimulator) {
        return abstractSimulators.contains(abstractSimulator.getClass());
    }

    @Override
    public boolean hasSimulator(Class<? extends AbstractSimulator> abstractSimulatorClass) {
        return abstractSimulators.contains(abstractSimulatorClass);
    }

    @Override
    public String getName() {
        return "RM";
    }


}