Changeset 1109 for trunk/autoquest-core-tasktrees

Timestamp:

02/21/13 18:39:48 (12 years ago)

Author:

pharms

Message:

• changed rules to be testable on their own
• added first version for a task detection rule
• refactored rules to have a simpler interface

Location:

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

Files:

• ComponentManager.java (modified) (1 diff)
• TaskTreeManager.java (modified) (6 diffs)

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/manager/ComponentManager.java

@@ -84 +84 @@
         nodeEqualityRuleManager.init();
 
-        temporalRelationshipRuleManager =
-            new TemporalRelationshipRuleManager(nodeEqualityRuleManager);
-        temporalRelationshipRuleManager.init();
-
         taskTreeBuilder = new TaskTreeBuilder();
         taskTreeNodeFactory = new TaskTreeNodeFactory();
+
+        temporalRelationshipRuleManager = new TemporalRelationshipRuleManager
+            (nodeEqualityRuleManager, taskTreeNodeFactory, taskTreeBuilder);
+        temporalRelationshipRuleManager.init();
     }
 

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManager.java

@@ -2 +2 @@
 
 import java.util.Collection;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.logging.Level;
 
 import de.ugoe.cs.autoquest.eventcore.Event;
-import de.ugoe.cs.autoquest.eventcore.gui.KeyboardFocusChange;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
 import de.ugoe.cs.util.console.Console;
@@ -24 +23 @@
     
     /** */
-    private static final int MAX_EVENTS_TILL_RULE_APPLICATION = 100;
-
-    /** */
     private ITaskTreeBuilder taskTreeBuilder = ComponentManager.getDefaultTaskTreeBuilder();
 
@@ -34 +30 @@
 
     /** */
-    private int eventsTillRuleApplication = MAX_EVENTS_TILL_RULE_APPLICATION;
+    private List<List<IEventTask>> sessions = null;
 
     /** */
-    private ISequence rootSequence;
+    private List<IEventTask> currentSession = null;
 
     /**
-     * TODO: comment
-     * 
+     *
      */
     public TaskTreeManager() {
-        rootSequence = taskTreeNodeFactory.createNewSequence();
+        sessions = new LinkedList<List<IEventTask>>();
     }
 
     /**
-     * <p>
-     * TODO: comment
-     * </p>
      *
-     * @param sequences
-     * @return
      */
-    public synchronized ITaskTree createTaskTree(Collection<List<Event>> sequences) {
+    public synchronized ITaskTree createTaskTree(Collection<List<Event>> newSessions) {
+        if ((currentSession != null) || (sessions.size() > 0)) {
+            throw new IllegalStateException("do not mix calls to this method with calls to the " +
+                                            "other methods for handling tasks. Use only one " +
+                                            "variant instead.");
+        }
         
-        for (List<Event> sequence : sequences) {
-            for (Event event : sequence) {
-                handleNewEvent(event);
+        for (List<Event> newSession : newSessions) {
+            if (newSession.size() > 0) {
+                for (Event event : newSession) {
+                    handleNewEvent(event);
+                }
+                finishSession();
             }
         }
@@ -70 +68 @@
      */
     public void handleNewEvent(Event event) {
-        handleEventTask(taskTreeNodeFactory.createNewEventTask(event.getType(), event.getTarget()));
+        assertSessionSequence();
+        currentSession.add
+            (taskTreeNodeFactory.createNewEventTask(event.getType(), event.getTarget()));
+    }
+
+    /**
+     * 
+     */
+    public void finishSession() {
+        if ((currentSession != null) && (currentSession.size() > 0)) {
+            sessions.add(currentSession);
+            currentSession = null;
+        }
     }
 
@@ -77 +87 @@
      */
     public synchronized ITaskTree getTaskTree() {
+        finishSession();
+        
         Console.traceln(Level.INFO, "applying temporal relationship generation rules");
+        
+        ISequence rootSequence = taskTreeNodeFactory.createNewSequence();
+        taskTreeBuilder.setDescription(rootSequence, "root");
+        
+        for (List<IEventTask> session : sessions) {
+            ISequence sequence = taskTreeNodeFactory.createNewSequence();
+            taskTreeBuilder.setDescription(sequence, "session");
+            
+            for (IEventTask eventTask : session) {
+                taskTreeBuilder.addChild(sequence, eventTask);
+            }
+            
+            taskTreeBuilder.addChild(rootSequence, sequence);
+        }
+        
+        
+        ComponentManager.getTemporalRelationshipRuleManager().applyRules(rootSequence);
 
-        ISequence currentRootSequence = rootSequence.clone();
-        ComponentManager.getTemporalRelationshipRuleManager().applyRules
-          (currentRootSequence, taskTreeBuilder, taskTreeNodeFactory, true);
-
-        return taskTreeNodeFactory.createTaskTree(currentRootSequence);
-    }
-
-    /**
-     * adds the task to the current or the new sequence. The decision depends on the type of task.
-     * If the task finishes the current sequence, the sequence is marked as finished If the task
-     * does not start a new sequence, it is added to the current sequence, before it is marked s
-     * finished. Otherwise it is added to a new sequence.
-     */
-    private synchronized void handleEventTask(IEventTask eventTask) {
-        if (!(eventTask.getEventType() instanceof KeyboardFocusChange)) {
-            Console.traceln(Level.INFO, "handling interaction event task \"" + eventTask + "\"");
-            addTaskToSequence(eventTask);
-        }
+        return taskTreeNodeFactory.createTaskTree(rootSequence);
     }
 
@@ -102 +114 @@
      *
      */
-    private void addTaskToSequence(ITaskTreeNode task)
-    {
-        taskTreeBuilder.addChild(rootSequence, task);
-
-        if (--eventsTillRuleApplication == 0) {
-            eventsTillRuleApplication = MAX_EVENTS_TILL_RULE_APPLICATION;
-
-            Console.traceln(Level.INFO, "applying temporal relationship generation rules");
-            ComponentManager.getTemporalRelationshipRuleManager().applyRules(rootSequence,
-                                                                             taskTreeBuilder,
-                                                                             taskTreeNodeFactory,
-                                                                             false);
+    private void assertSessionSequence() {
+        if (currentSession == null) {
+            currentSession = new LinkedList<IEventTask>();
         }
     }