Changeset 1294 for trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation

Timestamp:

08/14/13 17:04:42 (11 years ago)

Author:

pharms

Message:

• rework of task model to move event instance stuff to task instances
• introduction of sequence, selection, iteration and optional instances

Location:

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation

Files:

• ITaskInstanceScopeRule.java (moved) (moved from trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/ITaskInstanceListScopeRule.java) (3 diffs)
• ITemporalRelationshipRule.java (modified) (1 diff)
• RuleUtils.java (modified) (3 diffs)
• SequenceForTaskDetectionRule.java (modified) (11 diffs)
• TaskHandlingStrategy.java (modified) (3 diffs)
• TaskIdentityComparator.java (modified) (1 diff)
• TaskInstanceComparator.java (moved) (moved from trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskComparator.java) (2 diffs)
• TaskSymbolBucketedMap.java (modified) (4 diffs)
• TemporalRelationshipRuleManager.java (modified) (7 diffs)

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/ITaskInstanceScopeRule.java

@@ -15 +15 @@
 package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
 
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
 
 /**
  * <p>
- * a task instance list scope rule is able to detected temporal relationships between a list of task
- * instances provided to the {@link #apply(ITaskInstanceList)} method. A rule creates temporal
+ * a task instance scope rule is able to detected temporal relationships between the children of
+ * a task instance provided to the {@link #apply(ITaskInstance)} method. A rule creates temporal
  * relationships between the task instances, i.e. substructures in the task tree, if
  * it detects a temporal relationship and instantiates the temporal relationships accordingly.
@@ -27 +27 @@
  * @author Patrick Harms
  */
-interface ITaskInstanceListScopeRule extends ITemporalRelationshipRule {
+interface ITaskInstanceScopeRule extends ITemporalRelationshipRule {
 
   /**
    * <p>
-   * applies the rule to the given task instance list. The returned rule application result is null,
+   * applies the rule to the given task instance. The returned rule application result is null,
    * if the rule can not be applied, i.e. it does not detect a temporal relationship. It returns a
    * rule application result with a status {@link RuleApplicationStatus#RULE_APPLICATION_FINISHED}
@@ -37 +37 @@
    * </p>
    * 
-   * @param taskInstances the list of task instances to apply the rule on
+   * @param taskInstance the task instances to apply the rule on
    *                    
    * @return the rule application result as described.
    */
-  RuleApplicationResult apply(ITaskInstanceList taskInstances);
+  RuleApplicationResult apply(ITaskInstance taskInstance);
   
 }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/ITemporalRelationshipRule.java

@@ -19 +19 @@
  * a temporal relationship rule is the main interface for all rules applied for generating
  * temporal relationships in a task tree. It is just a marker interface. More important are the
- * sub interfaces {@link ISessionScopeRule} and {@link ITaskInstanceListScopeRule}.
+ * sub interfaces {@link ISessionScopeRule} and {@link ITaskInstanceScopeRule}.
  * </p>
  * 

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleUtils.java

@@ -15 +15 @@
 package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
 
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequenceInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
@@ -55 +56 @@
                                                int               startIndex,
                                                int               endIndex,
-                                               ITask             model,
+                                               ISequence         model,
                                                ITaskFactory      taskFactory,
                                                ITaskBuilder      taskBuilder)
     {
-        ITaskInstance subsequence = taskFactory.createNewTaskInstance(model);
+        ISequenceInstance subsequence = taskFactory.createNewTaskInstance(model);
 
         for (int i = startIndex; i <= endIndex; i++) {
@@ -83 +84 @@
      * @return the replacement for the range
      */
-    static ITaskInstance createNewSubSequenceInRange(ITaskInstanceList parent,
-                                                     int               startIndex,
-                                                     int               endIndex,
-                                                     ITask             model,
-                                                     ITaskFactory      taskFactory,
-                                                     ITaskBuilder      taskBuilder)
+    static ISequenceInstance createNewSubSequenceInRange(ITaskInstanceList parent,
+                                                         int               startIndex,
+                                                         int               endIndex,
+                                                         ISequence         model,
+                                                         ITaskFactory      taskFactory,
+                                                         ITaskBuilder      taskBuilder)
     {
-        ITaskInstance subsequence = taskFactory.createNewTaskInstance(model);
+        ISequenceInstance subsequence = taskFactory.createNewTaskInstance(model);
 
         for (int i = startIndex; i <= endIndex; i++) {

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRule.java

@@ -26 +26 @@
 import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIterationInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelectionInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequenceInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder;
@@ -159 +162 @@
         SymbolMap<ITaskInstance, ITask> uniqueTasks =
             preparationTaskHandlingStrategy.createSymbolMap();
-        TaskComparator comparator = preparationTaskHandlingStrategy.getTaskComparator();
+        TaskInstanceComparator comparator = preparationTaskHandlingStrategy.getTaskComparator();
         
         int unifiedTasks = 0;
@@ -235 +238 @@
     {
         Map<ITask, IIteration> iterations = new HashMap<ITask, IIteration>();
-        Map<IIteration, List<ITaskInstance>> iterationInstances =
-                new HashMap<IIteration, List<ITaskInstance>>();
+        Map<IIteration, List<IIterationInstance>> iterationInstances =
+                new HashMap<IIteration, List<IIterationInstance>>();
             
         for (ITask iteratedTask : iteratedTasks) {
             IIteration iteration = taskFactory.createNewIteration();
             iterations.put(iteratedTask, iteration);
-            iterationInstances.put(iteration, new LinkedList<ITaskInstance>());
-        }
-        
-        ITaskInstance iterationInstance = null;
+            iterationInstances.put(iteration, new LinkedList<IIterationInstance>());
+        }
+        
+        IIterationInstance iterationInstance = null;
         
         for (IUserSession session : sessions) {
@@ -275 +278 @@
         }
         
-        for (Map.Entry<IIteration, List<ITaskInstance>> entry : iterationInstances.entrySet()) {
+        for (Map.Entry<IIteration, List<IIterationInstance>> entry : iterationInstances.entrySet())
+        {
             harmonizeIterationInstancesModel(entry.getKey(), entry.getValue());
         }
@@ -283 +287 @@
      *
      */
-    private void harmonizeIterationInstancesModel(IIteration          iteration,
-                                                  List<ITaskInstance> iterationInstances)
+    private void harmonizeIterationInstancesModel(IIteration               iteration,
+                                                  List<IIterationInstance> iterationInstances)
     {
         List<ITask> iteratedTaskVariants = new LinkedList<ITask>();
-        TaskComparator comparator = preparationTaskHandlingStrategy.getTaskComparator();
+        TaskInstanceComparator comparator = preparationTaskHandlingStrategy.getTaskComparator();
         
         // merge the lexically different variants of iterated task to a unique list 
-        for (ITaskInstance iterationInstance : iterationInstances) {
+        for (IIterationInstance iterationInstance : iterationInstances) {
             for (ITaskInstance executionVariant : iterationInstance) {
                 ITask candidate = executionVariant.getTask();
@@ -323 +327 @@
             taskBuilder.setMarkedTask(iteration, selection);
             
-            for (ITaskInstance instance : iterationInstances) {
+            for (IIterationInstance instance : iterationInstances) {
                 for (int i = 0; i < instance.size(); i++) {
-                    ITaskInstance selectionInstance = taskFactory.createNewTaskInstance(selection);
-                    taskBuilder.addChild(selectionInstance, instance.get(i));
+                    ISelectionInstance selectionInstance =
+                        taskFactory.createNewTaskInstance(selection);
+                    taskBuilder.setChild(selectionInstance, instance.get(i));
                     taskBuilder.setTaskInstance(instance, i, selectionInstance);
                 }
@@ -490 +495 @@
                 Console.traceln(Level.FINEST, "replacing " + sequence.getId() + ": " + task);
 
-                List<ITaskInstance> sequenceInstances =
+                List<ISequenceInstance> sequenceInstances =
                     replaceTaskOccurrences(task, appData.getSessions(), sequence);
                 
@@ -510 +515 @@
      *
      */
-    private void harmonizeSequenceInstancesModel(ISequence           sequence,
-                                                 List<ITaskInstance> sequenceInstances,
-                                                 int                 sequenceLength)
+    private void harmonizeSequenceInstancesModel(ISequence               sequence,
+                                                 List<ISequenceInstance> sequenceInstances,
+                                                 int                     sequenceLength)
     {
-        TaskComparator comparator = preparationTaskHandlingStrategy.getTaskComparator();
+        TaskInstanceComparator comparator = preparationTaskHandlingStrategy.getTaskComparator();
         
         // ensure for each subtask that lexically different variants are preserved
@@ -520 +525 @@
             List<ITask> subTaskVariants = new LinkedList<ITask>();
             
-            for (ITaskInstance sequenceInstance : sequenceInstances) {
+            for (ISequenceInstance sequenceInstance : sequenceInstances) {
                 ITask candidate = sequenceInstance.get(subTaskIndex).getTask();
                 
@@ -556 +561 @@
                 taskBuilder.addChild(sequence, selection);
                 
-                for (ITaskInstance instance : sequenceInstances) {
-                    ITaskInstance selectionInstance =
+                for (ISequenceInstance instance : sequenceInstances) {
+                    ISelectionInstance selectionInstance =
                         taskFactory.createNewTaskInstance(selection);
-                    taskBuilder.addChild(selectionInstance, instance.get(subTaskIndex));
+                    taskBuilder.setChild(selectionInstance, instance.get(subTaskIndex));
                     taskBuilder.setTaskInstance(instance, subTaskIndex, selectionInstance);
                 }
@@ -572 +577 @@
      * @param tree
      */
-    private List<ITaskInstance> replaceTaskOccurrences(List<ITaskInstance> task,
-                                                       List<IUserSession>  sessions,
-                                                       ISequence           temporalTaskModel)
+    private List<ISequenceInstance> replaceTaskOccurrences(List<ITaskInstance> task,
+                                                           List<IUserSession>  sessions,
+                                                           ISequence           temporalTaskModel)
     {
-        List<ITaskInstance> sequenceInstances = new LinkedList<ITaskInstance>();
+        List<ISequenceInstance> sequenceInstances = new LinkedList<ISequenceInstance>();
         
         for (IUserSession session : sessions) {

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskHandlingStrategy.java

@@ -42 +42 @@
      * 
      */
-    private TaskComparator comparator;
+    private TaskInstanceComparator comparator;
 
     /**
@@ -58 +58 @@
         }
         else {
-            comparator = new TaskComparator(this.consideredEquality);
+            comparator = new TaskInstanceComparator(this.consideredEquality);
         }
     }
@@ -77 +77 @@
      * @return
      */
-    public TaskComparator getTaskComparator() {
+    public TaskInstanceComparator getTaskComparator() {
         return comparator;
     }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskIdentityComparator.java

@@ -21 +21 @@
  * TODO comment
  */
-class TaskIdentityComparator extends TaskComparator {
+class TaskIdentityComparator extends TaskInstanceComparator {
 
     /**  */

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskInstanceComparator.java

@@ -28 +28 @@
  * TODO comment
  */
-class TaskComparator implements SymbolComparator<ITaskInstance> {
+class TaskInstanceComparator implements SymbolComparator<ITaskInstance> {
     
     /**  */
@@ -54 +54 @@
      *
      */
-    public TaskComparator(TaskEquality minimalNodeEquality) {
+    public TaskInstanceComparator(TaskEquality minimalNodeEquality) {
         this.minimalNodeEquality = minimalNodeEquality;
         init();

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskSymbolBucketedMap.java

@@ -27 +27 @@
 
 import de.ugoe.cs.autoquest.eventcore.IEventType;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIterationInstance;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelectionInstance;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequenceInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
 import de.ugoe.cs.autoquest.usageprofiles.SymbolMap;
@@ -81 +80 @@
      * </p>
      */
-    private TaskComparator comparator;
+    private TaskInstanceComparator comparator;
 
     /**
@@ -117 +116 @@
      * @throws IllegalArgumentException if the provided comparator is null
      */
-    public TaskSymbolBucketedMap(TaskComparator comparator) {
+    public TaskSymbolBucketedMap(TaskInstanceComparator comparator) {
         if (comparator == null) {
             throw new IllegalArgumentException("comparator must not be null");
@@ -400 +399 @@
         // other = hashCode of name of event type
         
-        ITask task = taskInstance.getTask();
-        
-        if (task instanceof IEventTask) {
+        if (taskInstance instanceof IEventTaskInstance) {
             // event tasks are most likely equal to those of the event type with the same name,
             // Afterwards, they may be equal to iterations, optionals, other event tasks,
             // selections, and finally the rest.
-            IEventType eventType = ((IEventTask) task).getEventType();
+            IEventType eventType = ((IEventTaskInstance) taskInstance).getEvent().getType();
             return new int[] { eventType.getName().hashCode(), 2, 3, 4, 1 };                       
         }
-        else if (task instanceof ISequence) {
+        else if (taskInstance instanceof ISequenceInstance) {
             return new int[] { 0, 2, 3, 1 };                       
         }
-        else if (task instanceof ISelection) {
+        else if (taskInstance instanceof ISelectionInstance) {
             return new int[] { 1, 4, 2, 3 };                       
         }
-        else if (task instanceof IIteration) {
+        else if (taskInstance instanceof IIterationInstance) {
             return new int[] { 2, 1, 4 };                       
         }

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java

@@ -26 +26 @@
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession;
 import de.ugoe.cs.util.console.Console;
@@ -38 +37 @@
  * between tasks which are not only a major sequence. I.e. through the application of the
  * rules iterations and selections of tasks are detected. Which kind of temporal relations
- * between tasks are detected depends on the {@link ITaskInstanceListScopeRule}s known to
+ * between tasks are detected depends on the {@link ITaskInstanceScopeRule}s known to
  * this class.
  * </p>
- * <p>The class holds references to the appropriate {@link ITaskInstanceListScopeRule}s and calls
- * their {@link ITaskInstanceListScopeRule#apply(ITask, ITaskBuilder, ITaskFactory, boolean)}
+ * <p>The class holds references to the appropriate {@link ITaskInstanceScopeRule}s and calls
+ * their {@link ITaskInstanceScopeRule#apply(ITask, ITaskBuilder, ITaskFactory, boolean)}
  * method for each task in the task tree it is needed for. The general behavior of this class is
  * the following:
@@ -56 +55 @@
  *   <li>
  *     the class iterates its internal list of rules and calls their
- *     {@link ITaskInstanceListScopeRule#apply(ITask, ITaskBuilder, ITaskFactory, boolean)}
+ *     {@link ITaskInstanceScopeRule#apply(ITask, ITaskBuilder, ITaskFactory, boolean)}
  *     method.
  *   </li>
@@ -115 +114 @@
      * </p>
      */
-    private ITaskInstanceListScopeRule[] taskScopeRules;
+    private ITaskInstanceScopeRule[] taskScopeRules;
 
     /**
@@ -166 +165 @@
         //treeScopeRules.add(new DefaultGuiElementSequenceDetectionRule(frameFilter));
 
-        taskScopeRules = new ITaskInstanceListScopeRule[] {
+        taskScopeRules = new ITaskInstanceScopeRule[] {
             //new SequenceOnGuiElementDetectionRule(taskFactory, taskTreeBuilder),
             //new EventSequenceOnSameTargetDetectionRule(taskFactory, taskTreeBuilder),
@@ -262 +261 @@
      *                     on the recursion depth of calling this method.
      */
-    private int applyRules(ITaskInstanceListScopeRule[] rules,
-                           ITaskInstanceList            taskInstances,
+    private int applyRules(ITaskInstanceScopeRule[] rules,
+                           ITaskInstance                taskInstance,
                            String                       logIndent)
     {
-        Console.traceln(Level.FINER, logIndent + "applying rules for " + taskInstances.size() +
-                        " task instances");
+        Console.traceln(Level.FINER, logIndent + "applying rules on " + taskInstance);
 
         int noOfRuleApplications = 0;
 
-        for (ITaskInstanceListScopeRule rule : rules) {
+        for (ITaskInstanceScopeRule rule : rules) {
             RuleApplicationResult result;
             do {
                 Console.traceln
-                    (Level.FINER, logIndent + "trying rule " + rule + " on " + taskInstances);
-                result = rule.apply(taskInstances);
+                    (Level.FINER, logIndent + "trying rule " + rule + " on " + taskInstance);
+                result = rule.apply(taskInstance);
 
                 if ((result != null) &&
@@ -282 +280 @@
                 {
                     Console.traceln
-                        (Level.FINE, logIndent + "applied rule " + rule + " on " + taskInstances);
+                        (Level.FINE, logIndent + "applied rule " + rule + " on " + taskInstance);
                     noOfRuleApplications++;