Ignore:
Timestamp:
04/04/13 16:06:07 (12 years ago)
Author:
pharms
Message:
  • complete refactoring of task tree model with a separation of task models and task instances
  • appropriate adaptation of task tree generation process
  • appropriate adaptation of commands and task tree visualization
Location:
trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees
Files:
13 added
16 deleted
18 edited
12 copied
10 moved

Legend:

Unmodified
Added
Removed

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

    r1113 r1146  
    1515package de.ugoe.cs.autoquest.tasktrees.manager; 
    1616 
    17 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager; 
     17import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; 
    1818import de.ugoe.cs.autoquest.tasktrees.temporalrelation.TemporalRelationshipRuleManager; 
    19 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; 
    20 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; 
    21 import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder; 
    22 import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory; 
     19import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; 
     20import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
     21import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; 
     22import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; 
    2323 
    2424/** 
    … …  
    3737 
    3838    /** */ 
    39     private NodeEqualityRuleManager nodeEqualityRuleManager; 
     39    private TaskEqualityRuleManager taskEqualityRuleManager; 
    4040 
    4141    /** */ 
    42     private ITaskTreeBuilder taskTreeBuilder; 
     42    private ITaskBuilder taskBuilder; 
    4343 
    4444    /** */ 
    45     private ITaskTreeNodeFactory taskTreeNodeFactory; 
     45    private ITaskFactory taskFactory; 
    4646 
    4747    /** 
    … …  
    5555     * 
    5656     */ 
    57     public static NodeEqualityRuleManager getNodeEqualityRuleManager() { 
    58         return getInstance().nodeEqualityRuleManager; 
     57    public static TaskEqualityRuleManager getTaskEqualityRuleManager() { 
     58        return getInstance().taskEqualityRuleManager; 
    5959    } 
    6060 
    … …  
    6262     * 
    6363     */ 
    64     public static ITaskTreeBuilder getDefaultTaskTreeBuilder() { 
    65         return getInstance().taskTreeBuilder; 
     64    public static ITaskBuilder getDefaultTaskBuilder() { 
     65        return getInstance().taskBuilder; 
    6666    } 
    6767 
    … …  
    6969     * 
    7070     */ 
    71     public static ITaskTreeNodeFactory getDefaultTaskTreeNodeFactory() { 
    72         return getInstance().taskTreeNodeFactory; 
     71    public static ITaskFactory getDefaultTaskFactory() { 
     72        return getInstance().taskFactory; 
    7373    } 
    7474 
    … …  
    9595     */ 
    9696    private void init() { 
    97         nodeEqualityRuleManager = new NodeEqualityRuleManager(); 
    98         nodeEqualityRuleManager.init(); 
     97        taskEqualityRuleManager = new TaskEqualityRuleManager(); 
     98        taskEqualityRuleManager.init(); 
    9999 
    100         taskTreeBuilder = new TaskTreeBuilder(); 
    101         taskTreeNodeFactory = new TaskTreeNodeFactory(); 
     100        taskBuilder = new TaskBuilder(); 
     101        taskFactory = new TaskFactory(); 
    102102 
    103103        temporalRelationshipRuleManager = new TemporalRelationshipRuleManager 
    104             (nodeEqualityRuleManager, taskTreeNodeFactory, taskTreeBuilder); 
     104            (taskEqualityRuleManager, taskFactory, taskBuilder); 
    105105        temporalRelationshipRuleManager.init(); 
    106106    } 

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

    r1113 r1146  
    2121 
    2222import de.ugoe.cs.autoquest.eventcore.Event; 
    23 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; 
    24 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    25 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; 
    26 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; 
    27 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; 
     23import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
     24import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
     25import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; 
     26import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
     27import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession; 
    2828import de.ugoe.cs.util.console.Console; 
    2929 
    … …  
    3737     
    3838    /** */ 
    39     private ITaskTreeBuilder taskTreeBuilder = ComponentManager.getDefaultTaskTreeBuilder(); 
     39    private ITaskBuilder taskBuilder = ComponentManager.getDefaultTaskBuilder(); 
    4040 
    4141    /** */ 
    42     private ITaskTreeNodeFactory taskTreeNodeFactory = 
    43         ComponentManager.getDefaultTaskTreeNodeFactory(); 
     42    private ITaskFactory taskFactory = ComponentManager.getDefaultTaskFactory(); 
    4443 
    4544    /** */ 
    46     private List<List<IEventTask>> sessions = null; 
     45    private List<IUserSession> sessions = null; 
    4746 
    4847    /** */ 
    49     private List<IEventTask> currentSession = null; 
     48    private IUserSession currentSession = null; 
    5049 
    5150    /** 
    … …  
    5352     */ 
    5453    public TaskTreeManager() { 
    55         sessions = new LinkedList<List<IEventTask>>(); 
     54        sessions = new LinkedList<IUserSession>(); 
    5655    } 
    5756 
    … …  
    5958     * 
    6059     */ 
    61     public synchronized ITaskTree createTaskTree(Collection<List<Event>> newSessions) { 
     60    public synchronized ITaskModel createTaskModel(Collection<List<Event>> newSessions) { 
    6261        if ((currentSession != null) || (sessions.size() > 0)) { 
    6362            throw new IllegalStateException("do not mix calls to this method with calls to the " + 
    … …  
    7574        } 
    7675         
    77         return getTaskTree(); 
     76        return getTaskModel(); 
    7877    } 
    7978 
    … …  
    8382    public void handleNewEvent(Event event) { 
    8483        assertSessionSequence(); 
    85         currentSession.add 
    86             (taskTreeNodeFactory.createNewEventTask(event.getType(), event.getTarget())); 
     84        ITask eventTask = taskFactory.createNewEventTask(event.getType(), event.getTarget()); 
     85        taskBuilder.addExecutedTask(currentSession, taskFactory.createNewTaskInstance(eventTask)); 
    8786    } 
    8887 
    … …  
    9190     */ 
    9291    public void finishSession() { 
    93         if ((currentSession != null) && (currentSession.size() > 0)) { 
     92        if ((currentSession != null) && (currentSession.getExecutedTasks().size() > 0)) { 
    9493            sessions.add(currentSession); 
    9594            currentSession = null; 
    … …  
    10099     * 
    101100     */ 
    102     public synchronized ITaskTree getTaskTree() { 
     101    public synchronized ITaskModel getTaskModel() { 
    103102        finishSession(); 
    104103         
    105104        Console.traceln(Level.INFO, "applying temporal relationship generation rules"); 
    106105         
    107         ISequence rootSequence = taskTreeNodeFactory.createNewSequence(); 
    108         taskTreeBuilder.setDescription(rootSequence, "root"); 
    109          
    110         for (List<IEventTask> session : sessions) { 
    111             ISequence sequence = taskTreeNodeFactory.createNewSequence(); 
    112             taskTreeBuilder.setDescription(sequence, "session"); 
    113              
    114             for (IEventTask eventTask : session) { 
    115                 taskTreeBuilder.addChild(sequence, eventTask); 
    116             } 
    117              
    118             taskTreeBuilder.addChild(rootSequence, sequence); 
    119         } 
    120          
    121          
    122         ComponentManager.getTemporalRelationshipRuleManager().applyRules(rootSequence); 
     106        ComponentManager.getTemporalRelationshipRuleManager().applyRules(sessions); 
    123107 
    124         return taskTreeNodeFactory.createTaskTree(rootSequence); 
     108        return taskFactory.createTaskModel(sessions); 
    125109    } 
    126110 
    … …  
    130114    private void assertSessionSequence() { 
    131115        if (currentSession == null) { 
    132             currentSession = new LinkedList<IEventTask>(); 
     116            currentSession = taskFactory.createUserSession(); 
    133117        } 
    134118    } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/EventTaskComparisonRule.java

    r1125 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1616 
    1717import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; 
    18 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     18import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    1919 
    2020/** 
    2121 * <p> 
    22  * This rule identifies two task tree nodes as lexically equal, if they are both event tasks and 
     22 * This rule identifies two tasks as lexically equal, if they are both event tasks and 
    2323 * if their respective event types and targets equal.  
    2424 * </p> 
    … …  
    2626 * @author Patrick Harms 
    2727 */ 
    28 public class EventTaskComparisonRule implements NodeComparisonRule { 
     28public class EventTaskComparisonRule implements TaskComparisonRule { 
    2929     
    3030    /* (non-Javadoc) 
    31      * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode) 
     31     * @see NodeComparisonRule#isApplicable(ITask, ITask) 
    3232     */ 
    3333    @Override 
    34     public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) { 
    35         return (node1 instanceof IEventTask) && (node2 instanceof IEventTask); 
     34    public boolean isApplicable(ITask task1, ITask task2) { 
     35        return (task1 instanceof IEventTask) && (task2 instanceof IEventTask); 
    3636    } 
    3737 
    3838    /* (non-Javadoc) 
    39      * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode) 
     39     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask) 
    4040     */ 
    4141    @Override 
    42     public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    43         IEventTask task1 = (IEventTask) node1; 
    44         IEventTask task2 = (IEventTask) node2; 
     42    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     43        IEventTask eventTask1 = (IEventTask) task1; 
     44        IEventTask eventTask2 = (IEventTask) task2; 
    4545         
    46         return (task1.getEventType().equals(task2.getEventType()) && 
    47                 task1.getEventTarget().equals(task2.getEventTarget())); 
     46        return (eventTask1.getEventType().equals(eventTask2.getEventType()) && 
     47                eventTask1.getEventTarget().equals(eventTask2.getEventTarget())); 
    4848    } 
    4949 
    5050    /* (non-Javadoc) 
    51      * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     51     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask) 
    5252     */ 
    5353    @Override 
    54     public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    55         return areLexicallyEqual(node1, node2); 
     54    public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     55        return areLexicallyEqual(task1, task2); 
    5656    } 
    5757 
    5858    /* (non-Javadoc) 
    59      * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     59     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask) 
    6060     */ 
    6161    @Override 
    62     public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    63         return areLexicallyEqual(node1, node2); 
     62    public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     63        return areLexicallyEqual(task1, task2); 
    6464    } 
    6565 
    6666    @Override 
    67     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    68         if (areLexicallyEqual(node1, node2)) { 
    69             return NodeEquality.LEXICALLY_EQUAL; 
     67    public TaskEquality compare(ITask task1, ITask task2) { 
     68        if (areLexicallyEqual(task1, task2)) { 
     69            return TaskEquality.LEXICALLY_EQUAL; 
    7070        } 
    7171        else { 
    72             return NodeEquality.UNEQUAL; 
     72            return TaskEquality.UNEQUAL; 
    7373        } 
    7474    } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/GUIEventTaskComparisonRule.java

    r1125 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1616 
    1717import de.ugoe.cs.autoquest.eventcore.IEventTarget; 
    … …  
    4242import de.ugoe.cs.autoquest.eventcore.guimodel.IToolTip; 
    4343import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; 
    44 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     44import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    4545 
    4646/** 
    … …  
    5858 * @author Patrick Harms 
    5959 */ 
    60 public class GUIEventTaskComparisonRule implements NodeComparisonRule { 
     60public class GUIEventTaskComparisonRule implements TaskComparisonRule { 
    6161     
    6262    /* (non-Javadoc) 
    63      * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode) 
     63     * @see NodeComparisonRule#isApplicable(ITask, ITask) 
    6464     */ 
    6565    @Override 
    66     public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) { 
     66    public boolean isApplicable(ITask task1, ITask task2) { 
    6767        return 
    68             ((node1 instanceof IEventTask) && (node2 instanceof IEventTask) && 
    69             (((IEventTask) node1).getEventType() instanceof IInteraction) && 
    70             (((IEventTask) node2).getEventType() instanceof IInteraction)); 
     68            ((task1 instanceof IEventTask) && (task2 instanceof IEventTask) && 
     69            (((IEventTask) task1).getEventType() instanceof IInteraction) && 
     70            (((IEventTask) task2).getEventType() instanceof IInteraction)); 
    7171    } 
    7272 
    7373    /* (non-Javadoc) 
    74      * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode) 
     74     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask) 
    7575     */ 
    7676    @Override 
    77     public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    78         NodeEquality equality = getEquality(node1, node2, NodeEquality.LEXICALLY_EQUAL); 
    79         return (equality != null) && (equality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); 
     77    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     78        TaskEquality equality = getEquality(task1, task2, TaskEquality.LEXICALLY_EQUAL); 
     79        return (equality != null) && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); 
    8080    } 
    8181 
    8282    /* (non-Javadoc) 
    83      * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     83     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask) 
    8484     */ 
    8585    @Override 
    86     public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    87         NodeEquality equality = getEquality(node1, node2, NodeEquality.SYNTACTICALLY_EQUAL); 
    88         return (equality != null) && (equality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); 
     86    public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     87        TaskEquality equality = getEquality(task1, task2, TaskEquality.SYNTACTICALLY_EQUAL); 
     88        return (equality != null) && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); 
    8989    } 
    9090 
    9191    /* (non-Javadoc) 
    92      * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     92     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask) 
    9393     */ 
    9494    @Override 
    95     public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    96         NodeEquality equality = getEquality(node1, node2, NodeEquality.SEMANTICALLY_EQUAL); 
    97         return (equality != null) && (equality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); 
     95    public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     96        TaskEquality equality = getEquality(task1, task2, TaskEquality.SEMANTICALLY_EQUAL); 
     97        return (equality != null) && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); 
    9898    } 
    9999 
    100100    /* (non-Javadoc) 
    101      * @see NodeComparisonRule#compare(ITaskTreeNode, ITaskTreeNode) 
     101     * @see NodeComparisonRule#compare(ITask, ITask) 
    102102     */ 
    103103    @Override 
    104     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    105         return getEquality(node1, node2, null); 
    106     } 
    107  
    108     /** 
    109      *  
    110      */ 
    111     private NodeEquality getEquality(ITaskTreeNode node1, 
    112                                      ITaskTreeNode node2, 
    113                                      NodeEquality  requiredEqualityLevel) 
    114     { 
    115         IEventTask task1 = (IEventTask) node1; 
    116         IEventTask task2 = (IEventTask) node2; 
    117          
    118         if (!task1.getEventTarget().equals(task2.getEventTarget())) { 
    119             return NodeEquality.UNEQUAL; 
    120         } 
    121          
    122         IInteraction interaction1 = (IInteraction) task1.getEventType(); 
    123         IInteraction interaction2 = (IInteraction) task2.getEventType(); 
     104    public TaskEquality compare(ITask task1, ITask task2) { 
     105        return getEquality(task1, task2, null); 
     106    } 
     107 
     108    /** 
     109     *  
     110     */ 
     111    private TaskEquality getEquality(ITask task1, ITask task2, TaskEquality requiredEqualityLevel) { 
     112        IEventTask eventTask1 = (IEventTask) task1; 
     113        IEventTask eventTask2 = (IEventTask) task2; 
     114         
     115        if (!eventTask1.getEventTarget().equals(eventTask2.getEventTarget())) { 
     116            return TaskEquality.UNEQUAL; 
     117        } 
     118         
     119        IInteraction interaction1 = (IInteraction) eventTask1.getEventType(); 
     120        IInteraction interaction2 = (IInteraction) eventTask2.getEventType(); 
    124121         
    125122        return compareInteractions 
    126             (interaction1, interaction2, task1.getEventTarget(), requiredEqualityLevel); 
     123            (interaction1, interaction2, eventTask1.getEventTarget(), requiredEqualityLevel); 
    127124    } 
    128125 
    … …  
    145142     * @return as described 
    146143     */ 
    147     private NodeEquality compareInteractions(IInteraction interaction1, 
     144    private TaskEquality compareInteractions(IInteraction interaction1, 
    148145                                             IInteraction interaction2, 
    149146                                             IEventTarget eventTarget, 
    150                                              NodeEquality equalityLevel) 
    151     { 
    152         NodeEquality level = equalityLevel; 
     147                                             TaskEquality equalityLevel) 
     148    { 
     149        TaskEquality level = equalityLevel; 
    153150         
    154151        if (level == null) { 
    155             level = NodeEquality.LEXICALLY_EQUAL; 
     152            level = TaskEquality.LEXICALLY_EQUAL; 
    156153        } 
    157154         
    158155        if (interaction1 == interaction2) { 
    159             return NodeEquality.LEXICALLY_EQUAL; 
     156            return TaskEquality.LEXICALLY_EQUAL; 
    160157        } 
    161158        else if ((interaction1 instanceof KeyInteraction) && 
    … …  
    186183        } 
    187184        else if (interaction1.equals(interaction2)) { 
    188             return NodeEquality.LEXICALLY_EQUAL; 
     185            return TaskEquality.LEXICALLY_EQUAL; 
    189186        } 
    190187        else { 
    191             return NodeEquality.UNEQUAL; 
     188            return TaskEquality.UNEQUAL; 
    192189        } 
    193190    } 
    … …  
    204201     * @return 
    205202     */ 
    206     private NodeEquality compareKeyInteractions(KeyInteraction interaction1, 
     203    private TaskEquality compareKeyInteractions(KeyInteraction interaction1, 
    207204                                                KeyInteraction interaction2, 
    208                                                 NodeEquality   equalityLevel) 
     205                                                TaskEquality   equalityLevel) 
    209206    { 
    210207        if (((interaction1 instanceof KeyPressed) && (interaction2 instanceof KeyPressed)) || 
    … …  
    212209            ((interaction1 instanceof KeyTyped) && (interaction2 instanceof KeyTyped))) 
    213210        { 
    214             if ((equalityLevel.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)) && 
     211            if ((equalityLevel.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)) && 
    215212                (interaction1.getKey() == interaction2.getKey())) 
    216213            { 
    217                 return NodeEquality.LEXICALLY_EQUAL; 
     214                return TaskEquality.LEXICALLY_EQUAL; 
    218215            } 
    219216            else { 
    220                 return NodeEquality.SEMANTICALLY_EQUAL; 
    221             } 
    222         } 
    223          
    224         return NodeEquality.UNEQUAL; 
     217                return TaskEquality.SEMANTICALLY_EQUAL; 
     218            } 
     219        } 
     220         
     221        return TaskEquality.UNEQUAL; 
    225222    } 
    226223     
    … …  
    236233     * @return as described 
    237234     */ 
    238     private NodeEquality compareMouseDragAndDrops(MouseDragAndDrop interaction1, 
     235    private TaskEquality compareMouseDragAndDrops(MouseDragAndDrop interaction1, 
    239236                                                  MouseDragAndDrop interaction2, 
    240                                                   NodeEquality     equalityLevel) 
     237                                                  TaskEquality     equalityLevel) 
    241238    { 
    242239        if (interaction1.getButton() != interaction2.getButton()) { 
    243             return NodeEquality.UNEQUAL; 
    244         } 
    245          
    246         if (equalityLevel.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)) { 
     240            return TaskEquality.UNEQUAL; 
     241        } 
     242         
     243        if (equalityLevel.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)) { 
    247244            int x1 = interaction1.getX(); 
    248245            int x1Start = interaction1.getXStart(); 
    … …  
    255252         
    256253            if ((x1Start == x2Start) && (x1 == x2) && (y1Start == y2Start) && (y1 == y2)) { 
    257                 return NodeEquality.LEXICALLY_EQUAL; 
    258             } 
    259         } 
    260          
    261         return NodeEquality.SEMANTICALLY_EQUAL; 
     254                return TaskEquality.LEXICALLY_EQUAL; 
     255            } 
     256        } 
     257         
     258        return TaskEquality.SEMANTICALLY_EQUAL; 
    262259    } 
    263260 
    … …  
    279276     * @return as described 
    280277     */ 
    281     private NodeEquality compareMouseButtonInteractions(MouseButtonInteraction interaction1, 
     278    private TaskEquality compareMouseButtonInteractions(MouseButtonInteraction interaction1, 
    282279                                                        MouseButtonInteraction interaction2, 
    283280                                                        IEventTarget           eventTarget, 
    284                                                         NodeEquality           equalityLevel) 
     281                                                        TaskEquality           equalityLevel) 
    285282    { 
    286283        boolean coordinatesMatch = true; 
    … …  
    293290        } 
    294291        else if (interaction1.getButton() != interaction2.getButton()) { 
    295             return NodeEquality.UNEQUAL; 
    296         } 
    297         else if (equalityLevel.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL) && 
     292            return TaskEquality.UNEQUAL; 
     293        } 
     294        else if (equalityLevel.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL) && 
    298295                 clickCoordinatesMakeLexicalDifference(eventTarget)) 
    299296        { 
    … …  
    319316        { 
    320317            if (coordinatesMatch) { 
    321                 return NodeEquality.LEXICALLY_EQUAL; 
     318                return TaskEquality.LEXICALLY_EQUAL; 
    322319            } 
    323320            else { 
    324                 return NodeEquality.SEMANTICALLY_EQUAL; 
    325             } 
    326         } 
    327          
    328         return NodeEquality.UNEQUAL; 
     321                return TaskEquality.SEMANTICALLY_EQUAL; 
     322            } 
     323        } 
     324         
     325        return TaskEquality.UNEQUAL; 
    329326    } 
    330327 
    … …  
    346343     * @return as described 
    347344     */ 
    348     private NodeEquality compareScrolls(Scroll       interaction1, 
     345    private TaskEquality compareScrolls(Scroll       interaction1, 
    349346                                        Scroll       interaction2, 
    350                                         NodeEquality equalityLevel) 
    351     { 
    352         if (equalityLevel.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)) { 
     347                                        TaskEquality equalityLevel) 
     348    { 
     349        if (equalityLevel.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)) { 
    353350            int x1 = interaction1.getXPosition(); 
    354351            int x2 = interaction2.getXPosition(); 
    … …  
    357354         
    358355            if ((x1 == x2) && (y1 == y2)) { 
    359                 return NodeEquality.LEXICALLY_EQUAL; 
    360             } 
    361         } 
    362          
    363         return NodeEquality.SEMANTICALLY_EQUAL; 
     356                return TaskEquality.LEXICALLY_EQUAL; 
     357            } 
     358        } 
     359         
     360        return TaskEquality.SEMANTICALLY_EQUAL; 
    364361    } 
    365362 
    … …  
    377374     * @return as described 
    378375     */ 
    379     private NodeEquality compareTextInputs(TextInput    interaction1, 
     376    private TaskEquality compareTextInputs(TextInput    interaction1, 
    380377                                           TextInput    interaction2, 
    381                                            NodeEquality equalityLevel) 
     378                                           TaskEquality equalityLevel) 
    382379    { 
    383380        switch (equalityLevel) { 
    384381            case LEXICALLY_EQUAL: 
    385382                if (interaction1.getTextInputEvents().equals(interaction2.getTextInputEvents())) { 
    386                     return NodeEquality.LEXICALLY_EQUAL; 
     383                    return TaskEquality.LEXICALLY_EQUAL; 
    387384                } 
    388385                // fall through 
    389386            case SYNTACTICALLY_EQUAL: 
    390387                if (interaction1.getEnteredText().equals(interaction2.getEnteredText())) { 
    391                     return NodeEquality.SYNTACTICALLY_EQUAL; 
     388                    return TaskEquality.SYNTACTICALLY_EQUAL; 
    392389                } 
    393390                // fall through 
    394391            case SEMANTICALLY_EQUAL: 
    395                 return NodeEquality.SEMANTICALLY_EQUAL; 
     392                return TaskEquality.SEMANTICALLY_EQUAL; 
    396393            default: 
    397                 return NodeEquality.UNEQUAL; 
     394                return TaskEquality.UNEQUAL; 
    398395        } 
    399396    } 
    … …  
    411408     * @return as described 
    412409     */ 
    413     private NodeEquality compareValueSelections(ValueSelection<?> interaction1, 
     410    private TaskEquality compareValueSelections(ValueSelection<?> interaction1, 
    414411                                                ValueSelection<?> interaction2, 
    415                                                 NodeEquality      equalityLevel) 
    416     { 
    417         if (equalityLevel.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)) { 
     412                                                TaskEquality      equalityLevel) 
     413    { 
     414        if (equalityLevel.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)) { 
    418415            Object value1 = interaction1.getSelectedValue(); 
    419416            Object value2 = interaction2.getSelectedValue(); 
    420417         
    421418            if ((value1 == value2) || ((value1 != null) && (value1.equals(value2)))) { 
    422                 return NodeEquality.LEXICALLY_EQUAL; 
    423             } 
    424         } 
    425          
    426         return NodeEquality.SEMANTICALLY_EQUAL; 
     419                return TaskEquality.LEXICALLY_EQUAL; 
     420            } 
     421        } 
     422         
     423        return TaskEquality.SEMANTICALLY_EQUAL; 
    427424    } 
    428425 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/IterationComparisonRule.java

    r1125 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
    16  
    17 import java.util.List; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1816 
    1917import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; 
    … …  
    2119import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; 
    2220import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    23 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     21import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2422 
    2523/** 
    … …  
    8179 * @author 2012, last modified by $Author: patrick$ 
    8280 */ 
    83 public class IterationComparisonRule implements NodeComparisonRule { 
     81public class IterationComparisonRule implements TaskComparisonRule { 
    8482     
    85     /** the rule manager for internally comparing task tree nodes */ 
    86     private NodeEqualityRuleManager mRuleManager; 
     83    /** the rule manager for internally comparing tasks */ 
     84    private TaskEqualityRuleManager mRuleManager; 
    8785 
    8886    /** 
    8987     * <p> 
    90      * simple constructor to provide the rule with the node equality rule manager to be able 
    91      * to perform comparisons of the children of provided task tree nodes 
     88     * simple constructor to provide the rule with the task equality rule manager to be able 
     89     * to perform comparisons of the children of provided tasks 
    9290     * </p> 
    9391     *  
    94      * @param ruleManager the rule manager for comparing task tree nodes 
    95      */ 
    96     IterationComparisonRule(NodeEqualityRuleManager ruleManager) { 
     92     * @param ruleManager the rule manager for comparing tasks 
     93     */ 
     94    IterationComparisonRule(TaskEqualityRuleManager ruleManager) { 
    9795        super(); 
    9896        mRuleManager = ruleManager; 
    … …  
    10098 
    10199    /* (non-Javadoc) 
    102      * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode) 
    103      */ 
    104     @Override 
    105     public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) { 
    106         return (node1 instanceof IIteration) && (node2 instanceof IIteration); 
    107     } 
    108  
    109     /* (non-Javadoc) 
    110      * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode) 
    111      */ 
    112     @Override 
    113     public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    114         List<ITaskTreeNode> children1 = node1.getChildren(); 
    115         List<ITaskTreeNode> children2 = node2.getChildren(); 
    116          
    117         if (children1.size() == children2.size()) { 
    118             if (children1.size() == 0) { 
    119                 return true; 
     100     * @see NodeComparisonRule#isApplicable(ITask, ITask) 
     101     */ 
     102    @Override 
     103    public boolean isApplicable(ITask task1, ITask task2) { 
     104        return (task1 instanceof IIteration) && (task2 instanceof IIteration); 
     105    } 
     106 
     107    /* (non-Javadoc) 
     108     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask) 
     109     */ 
     110    @Override 
     111    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     112        ITask child1 = ((IIteration) task1).getMarkedTask(); 
     113        ITask child2 = ((IIteration) task2).getMarkedTask(); 
     114         
     115        if (child1 != null) { 
     116            if (child2 == null) { 
     117                return false; 
    120118            } 
    121119            else { 
    122                 ITaskTreeNode child1 = children1.get(0); 
    123                 ITaskTreeNode child2 = children2.get(0); 
    124                  
    125120                // iterations may have 3 different structures. 
    126121                // 1. they have one child, which is the iterated one 
    … …  
    136131                { 
    137132                    return getNodeEquality 
    138                         (child1, child2).isAtLeast(NodeEquality.LEXICALLY_EQUAL); 
     133                        (child1, child2).isAtLeast(TaskEquality.LEXICALLY_EQUAL); 
    139134                } 
    140135            } 
    141136        } 
     137        else if (child2 == null) { 
     138            return true; 
     139        } 
    142140         
    143141        return false; 
    … …  
    145143 
    146144    /* (non-Javadoc) 
    147      * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode) 
    148      */ 
    149     @Override 
    150     public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    151         List<ITaskTreeNode> children1 = node1.getChildren(); 
    152         List<ITaskTreeNode> children2 = node2.getChildren(); 
    153          
    154         if (children1.size() == children2.size()) { 
    155             if (children1.size() == 0) { 
    156                 return true; 
     145     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask) 
     146     */ 
     147    @Override 
     148    public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     149        ITask child1 = ((IIteration) task1).getMarkedTask(); 
     150        ITask child2 = ((IIteration) task2).getMarkedTask(); 
     151         
     152        if (child1 != null) { 
     153            if (child2 == null) { 
     154                return false; 
    157155            } 
    158156            else { 
    159                 ITaskTreeNode child1 = children1.get(0); 
    160                 ITaskTreeNode child2 = children2.get(0); 
    161                  
    162157                // iterations may have 3 different structures. 
    163158                // 1. they have one child, which is the iterated one 
    … …  
    167162                // ignore the type of the children but check them for equality. 
    168163                 
    169                 return getNodeEquality(child1, child2).isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL); 
    170             } 
     164                return getNodeEquality(child1, child2).isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL); 
     165            } 
     166        } 
     167        else if (child2 == null) { 
     168            return true; 
    171169        } 
    172170         
    … …  
    175173 
    176174    /* (non-Javadoc) 
    177      * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode) 
    178      */ 
    179     @Override 
    180     public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    181         return compare(node1, node2).isAtLeast(NodeEquality.SEMANTICALLY_EQUAL); 
    182     } 
    183  
    184     /* (non-Javadoc) 
    185      * @see NodeComparisonRule#compare(ITaskTreeNode, ITaskTreeNode) 
    186      */ 
    187     @Override 
    188     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    189         List<ITaskTreeNode> children1 = node1.getChildren(); 
    190         List<ITaskTreeNode> children2 = node2.getChildren(); 
     175     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask) 
     176     */ 
     177    @Override 
     178    public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     179        return compare(task1, task2).isAtLeast(TaskEquality.SEMANTICALLY_EQUAL); 
     180    } 
     181 
     182    /* (non-Javadoc) 
     183     * @see NodeComparisonRule#compare(ITask, ITask) 
     184     */ 
     185    @Override 
     186    public TaskEquality compare(ITask task1, ITask task2) { 
     187        ITask child1 = ((IIteration) task1).getMarkedTask(); 
     188        ITask child2 = ((IIteration) task2).getMarkedTask(); 
    191189 
    192190        // if both iterations do not have children, they are equal although this doesn't make sense 
    193         if ((children1.size() == 0) && (children2.size() == 0)) { 
    194             return NodeEquality.LEXICALLY_EQUAL; 
    195         } 
    196         else if ((children1.size() == 0) || (children2.size() == 0)) { 
    197             return NodeEquality.UNEQUAL; 
    198         } 
    199  
    200         ITaskTreeNode child1 = children1.get(0); 
    201         ITaskTreeNode child2 = children2.get(0); 
     191        if ((child1 == null) && (child2 == null)) { 
     192            return TaskEquality.LEXICALLY_EQUAL; 
     193        } 
     194        else if ((child1 == null) || (child2 == null)) { 
     195            return TaskEquality.UNEQUAL; 
     196        } 
    202197 
    203198        // iterations may have 3 different structures. 
    … …  
    209204        // the permutations of the three variants in combination must be checked 
    210205 
    211         // check if both nodes are the same variants of iterations and if their children are equal. 
     206        // check if both tasks are the same variants of iterations and if their children are equal. 
    212207        // This condition matches, if both iterations are the same variants of iteration. I.e. three 
    213208        // combinations of the permutation are handled herewith. 
    214         NodeEquality nodeEquality = getNodeEquality(child1, child2); 
    215          
    216         if (nodeEquality != null) { 
    217             return nodeEquality; 
    218         } 
    219  
    220         // compare one iteration with a single node as a child and another one with a selection of 
    221         // semantically equal nodes 
     209        TaskEquality taskEquality = getNodeEquality(child1, child2); 
     210         
     211        if (taskEquality != null) { 
     212            return taskEquality; 
     213        } 
     214 
     215        // compare one iteration with a single task as a child and another one with a selection of 
     216        // semantically equal tasks 
    222217        return selectionChildrenSemanticallyEqualNode(child1, child2); 
    223218         
    … …  
    229224     * TODO update comment 
    230225     */ 
    231     private NodeEquality getNodeEquality(ITaskTreeNode child1, ITaskTreeNode child2) { 
    232         NodeEquality nodeEquality = callRuleManager(child1, child2, null); 
    233  
    234         if (nodeEquality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)) { 
     226    private TaskEquality getNodeEquality(ITask child1, ITask child2) { 
     227        TaskEquality taskEquality = callRuleManager(child1, child2, null); 
     228 
     229        if (taskEquality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)) { 
    235230            // prevent, that identical is returned, because the iterations itself are not identical 
    236231            // although the iterated tasks are 
    237             if (nodeEquality == NodeEquality.IDENTICAL) { 
    238                 return NodeEquality.LEXICALLY_EQUAL; 
     232            if (taskEquality == TaskEquality.IDENTICAL) { 
     233                return TaskEquality.LEXICALLY_EQUAL; 
    239234            } 
    240235            else { 
    241                 return nodeEquality; 
    242             } 
    243         } 
    244          
    245         return NodeEquality.UNEQUAL; 
     236                return taskEquality; 
     237            } 
     238        } 
     239         
     240        return TaskEquality.UNEQUAL; 
    246241    } 
    247242 
    248243    /** 
    249244     * <p> 
    250      * compares two task tree nodes. One of them must be a selection, the other one can be any task 
    251      * tree node. The method returns a node equality that is not <code>NodeEquality.UNEQUAL</code> 
    252      * if the other node is at least semantically equal to the children of the selection. It 
    253      * returns more concrete equalities, if the equality between the other node and the children 
     245     * compares two tasks. One of them must be a selection, the other one can be any task 
     246     * tree task. The method returns a task equality that is not <code>NodeEquality.UNEQUAL</code> 
     247     * if the other task is at least semantically equal to the children of the selection. It 
     248     * returns more concrete equalities, if the equality between the other task and the children 
    254249     * of the selection is more concrete. 
    255250     * </p>  
    256251     *  
    257      * @param taskTreeNode  the first task tree node to compare 
    258      * @param taskTreeNode2 the second task tree node to compare 
     252     * @param taskTreeNode  the first task to compare 
     253     * @param taskTreeNode2 the second task to compare 
    259254     *  
    260255     * @return as described 
    261256     */ 
    262     private NodeEquality selectionChildrenSemanticallyEqualNode(ITaskTreeNode taskTreeNode, 
    263                                                                 ITaskTreeNode taskTreeNode2) 
    264     { 
     257    private TaskEquality selectionChildrenSemanticallyEqualNode(ITask task1, ITask task2) { 
    265258        ISelection selection = null; 
    266         ITaskTreeNode node = null; 
    267         if (taskTreeNode instanceof ISelection) { 
    268             selection = (ISelection) taskTreeNode; 
    269             node = taskTreeNode2; 
    270         } 
    271         else if (taskTreeNode2 instanceof ISelection) { 
    272             selection = (ISelection) taskTreeNode2; 
    273             node = taskTreeNode; 
     259        ITask task = null; 
     260        if (task1 instanceof ISelection) { 
     261            selection = (ISelection) task1; 
     262            task = task2; 
     263        } 
     264        else if (task2 instanceof ISelection) { 
     265            selection = (ISelection) task2; 
     266            task = task1; 
    274267        } 
    275268        else { 
    276             return NodeEquality.UNEQUAL; 
     269            return TaskEquality.UNEQUAL; 
    277270        } 
    278271 
    279272        // Iterations, where one has a selection and the other one not can at most be syntactically 
    280273        // equal but not identical 
    281         NodeEquality commonDenominatorForAllComparisons = NodeEquality.SYNTACTICALLY_EQUAL; 
    282  
    283         for (ITaskTreeNode child : selection.getChildren()) { 
    284             NodeEquality nodeEquality = 
    285                   callRuleManager(node, child, commonDenominatorForAllComparisons); 
    286  
    287             if ((nodeEquality == null) || (nodeEquality == NodeEquality.UNEQUAL)) 
     274        TaskEquality commonDenominatorForAllComparisons = TaskEquality.SYNTACTICALLY_EQUAL; 
     275 
     276        for (ITask child : selection.getChildren()) { 
     277            TaskEquality taskEquality = 
     278                  callRuleManager(task, child, commonDenominatorForAllComparisons); 
     279 
     280            if ((taskEquality == null) || (taskEquality == TaskEquality.UNEQUAL)) 
    288281            { 
    289                 return NodeEquality.UNEQUAL; 
     282                return TaskEquality.UNEQUAL; 
    290283            } 
    291284             
    292285            commonDenominatorForAllComparisons = 
    293                 commonDenominatorForAllComparisons.getCommonDenominator(nodeEquality); 
     286                commonDenominatorForAllComparisons.getCommonDenominator(taskEquality); 
    294287        } 
    295288 
    … …  
    307300     * @return 
    308301     */ 
    309     private NodeEquality callRuleManager(ITaskTreeNode child1, 
    310                                          ITaskTreeNode child2, 
    311                                          NodeEquality requiredEqualityLevel) 
     302    private TaskEquality callRuleManager(ITask        child1, 
     303                                         ITask        child2, 
     304                                         TaskEquality requiredEqualityLevel) 
    312305    { 
    313306        if (requiredEqualityLevel == null) { 
    … …  
    318311        } 
    319312        else { 
    320             return NodeEquality.UNEQUAL; 
     313            return TaskEquality.UNEQUAL; 
    321314        } 
    322315    } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SelectionComparisonRule.java

    r1125 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1616 
    1717import java.util.List; 
    1818 
    1919import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; 
    20 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     20import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2121 
    2222/** 
    2323 * <p> 
    24  * this node comparison rule is capable of comparing selections. If both selections do not have 
    25  * children, they are treated as identical. If they have children, each child of both selections 
    26  * is compared to each child of the respective other selection. The resulting equality is the most 
    27  * concrete one of all these comparisons. I.e. if all children are at least lexically equal, then 
    28  * the selections are lexically equal. If all children are at least syntactically equal, then the 
    29  * selections are syntactically equal. If all children are at least semantically equal, then the 
    30  * selections are semantically equal. If only one of the selections has children, then the 
    31  * selections are unequal. 
     24 * this task comparison rule is capable of comparing selections. If both selections do not have 
     25 * children, they are treated as lexically equal. If they have children, each child of both 
     26 * selections is compared to each child of the respective other selection. The resulting equality 
     27 * is the most concrete one of all these comparisons. I.e. if all children are at least lexically 
     28 * equal, then the selections are lexically equal. If all children are at least syntactically 
     29 * equal, then the selections are syntactically equal. If all children are at least semantically 
     30 * equal, then the selections are semantically equal. If only one of the selections has children, 
     31 * then the selections are unequal. 
    3232 * </p> 
    3333 *  
    … …  
    3535 * @author 2012, last modified by $Author: patrick$ 
    3636 */ 
    37 public class SelectionComparisonRule implements NodeComparisonRule { 
    38  
    39     /** the rule manager for internally comparing task tree nodes */ 
    40     private NodeEqualityRuleManager mRuleManager; 
    41  
    42     /** 
    43      * <p> 
    44      * simple constructor to provide the rule with the node equality rule manager to be able 
    45      * to perform comparisons of the children of provided task tree nodes 
     37public class SelectionComparisonRule implements TaskComparisonRule { 
     38 
     39    /** the rule manager for internally comparing tasks */ 
     40    private TaskEqualityRuleManager mRuleManager; 
     41 
     42    /** 
     43     * <p> 
     44     * simple constructor to provide the rule with the task equality rule manager to be able 
     45     * to perform comparisons of the children of provided tasks 
    4646     * </p> 
    4747     *  
    48      * @param ruleManager the rule manager for comparing task tree nodes 
    49      */ 
    50     SelectionComparisonRule(NodeEqualityRuleManager ruleManager) { 
     48     * @param ruleManager the rule manager for comparing tasks 
     49     */ 
     50    SelectionComparisonRule(TaskEqualityRuleManager ruleManager) { 
    5151        super(); 
    5252        mRuleManager = ruleManager; 
    … …  
    5454 
    5555    /* (non-Javadoc) 
    56      * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode) 
    57      */ 
    58     @Override 
    59     public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) { 
    60         return (node1 instanceof ISelection) && (node2 instanceof ISelection); 
    61     } 
    62  
    63     /* (non-Javadoc) 
    64      * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode) 
    65      */ 
    66     @Override 
    67     public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    68         NodeEquality equality = getEquality(node1, node2, NodeEquality.LEXICALLY_EQUAL); 
    69         return (equality != null) && (equality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); 
    70     } 
    71  
    72     /* (non-Javadoc) 
    73      * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode) 
    74      */ 
    75     @Override 
    76     public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    77         NodeEquality equality = getEquality(node1, node2, NodeEquality.SYNTACTICALLY_EQUAL); 
    78         return (equality != null) && (equality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); 
    79     } 
    80  
    81     /* (non-Javadoc) 
    82      * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode) 
    83      */ 
    84     @Override 
    85     public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    86         NodeEquality equality = getEquality(node1, node2, NodeEquality.SEMANTICALLY_EQUAL); 
    87         return (equality != null) && (equality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); 
    88     } 
    89  
    90     /* (non-Javadoc) 
    91      * @see NodeComparisonRule#compare(ITaskTreeNode, ITaskTreeNode) 
    92      */ 
    93     @Override 
    94     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    95         return getEquality(node1, node2, null); 
     56     * @see NodeComparisonRule#isApplicable(ITask, ITask) 
     57     */ 
     58    @Override 
     59    public boolean isApplicable(ITask task1, ITask task2) { 
     60        return (task1 instanceof ISelection) && (task2 instanceof ISelection); 
     61    } 
     62 
     63    /* (non-Javadoc) 
     64     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask) 
     65     */ 
     66    @Override 
     67    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     68        TaskEquality equality = getEquality(task1, task2, TaskEquality.LEXICALLY_EQUAL); 
     69        return (equality != null) && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); 
     70    } 
     71 
     72    /* (non-Javadoc) 
     73     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask) 
     74     */ 
     75    @Override 
     76    public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     77        TaskEquality equality = getEquality(task1, task2, TaskEquality.SYNTACTICALLY_EQUAL); 
     78        return (equality != null) && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); 
     79    } 
     80 
     81    /* (non-Javadoc) 
     82     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask) 
     83     */ 
     84    @Override 
     85    public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     86        TaskEquality equality = getEquality(task1, task2, TaskEquality.SEMANTICALLY_EQUAL); 
     87        return (equality != null) && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); 
     88    } 
     89 
     90    /* (non-Javadoc) 
     91     * @see NodeComparisonRule#compare(ITask, ITask) 
     92     */ 
     93    @Override 
     94    public TaskEquality compare(ITask task1, ITask task2) { 
     95        return getEquality(task1, task2, null); 
    9696    } 
    9797 
    … …  
    9999     *  
    100100     */ 
    101     private NodeEquality getEquality(ITaskTreeNode node1, 
    102                                      ITaskTreeNode node2, 
    103                                      NodeEquality  requiredEqualityLevel) 
    104     { 
    105         List<ITaskTreeNode> children1 = node1.getChildren(); 
    106         List<ITaskTreeNode> children2 = node2.getChildren(); 
     101    private TaskEquality getEquality(ITask task1, ITask task2, TaskEquality requiredEqualityLevel) { 
     102        List<ITask> children1 = ((ISelection) task1).getChildren(); 
     103        List<ITask> children2 = ((ISelection) task2).getChildren(); 
    107104 
    108105        // if both selections do not have children, they are lexically equal. If only one of them 
    109106        // has children, they are unequal. 
    110107        if ((children1.size() == 0) && (children2.size() == 0)) { 
    111             return NodeEquality.LEXICALLY_EQUAL; 
     108            return TaskEquality.LEXICALLY_EQUAL; 
    112109        } 
    113110        else if ((children1.size() == 0) || (children2.size() == 0)) { 
    114             return NodeEquality.UNEQUAL; 
    115         } 
    116  
    117         NodeEquality selectionEquality; 
     111            return TaskEquality.UNEQUAL; 
     112        } 
     113 
     114        TaskEquality selectionEquality; 
    118115 
    119116        if (requiredEqualityLevel == null) { 
    … …  
    121118            // do it in both directions to ensure commutative comparison 
    122119            selectionEquality = getCommonEqualityLevel(children1, children2); 
    123             if (selectionEquality != NodeEquality.UNEQUAL) { 
     120            if (selectionEquality != TaskEquality.UNEQUAL) { 
    124121                return selectionEquality.getCommonDenominator 
    125122                    (getCommonEqualityLevel(children2, children1)); 
    126123            } 
    127124            else { 
    128                 return NodeEquality.UNEQUAL; 
     125                return TaskEquality.UNEQUAL; 
    129126            } 
    130127        } 
    … …  
    137134            } 
    138135            else { 
    139                 return NodeEquality.UNEQUAL; 
     136                return TaskEquality.UNEQUAL; 
    140137            } 
    141138        } 
    … …  
    151148     * @param requiredEqualityLevel 
    152149     */ 
    153     private NodeEquality getCommonEqualityLevel(List<ITaskTreeNode> children1, 
    154                                                 List<ITaskTreeNode> children2) 
    155     { 
    156         NodeEquality listEquality = NodeEquality.LEXICALLY_EQUAL; 
     150    private TaskEquality getCommonEqualityLevel(List<ITask> children1, List<ITask> children2) { 
     151        TaskEquality listEquality = TaskEquality.LEXICALLY_EQUAL; 
    157152         
    158         NodeEquality childEquality; 
    159         NodeEquality currentEquality; 
    160         for (ITaskTreeNode child1 : children1) { 
     153        TaskEquality childEquality; 
     154        TaskEquality currentEquality; 
     155        for (ITask child1 : children1) { 
    161156            childEquality = null; 
    162             for (ITaskTreeNode child2 : children2) { 
     157            for (ITask child2 : children2) { 
    163158                currentEquality = callRuleManager(child1, child2, null); 
    164                 if ((currentEquality != null) && (currentEquality != NodeEquality.UNEQUAL)) { 
     159                if ((currentEquality != null) && (currentEquality != TaskEquality.UNEQUAL)) { 
    165160                    if (childEquality == null) { 
    166161                        childEquality = currentEquality; 
    … …  
    170165                    } 
    171166                     
    172                     if (childEquality == NodeEquality.SEMANTICALLY_EQUAL) { 
     167                    if (childEquality == TaskEquality.SEMANTICALLY_EQUAL) { 
    173168                        // as we calculate only the common denominator, we can break up here for 
    174169                        // the current child. We will not improve the denominator anymore 
    … …  
    181176                // we did not find any child in the second list, that is equal to the searched 
    182177                // child 
    183                 return NodeEquality.UNEQUAL; 
     178                return TaskEquality.UNEQUAL; 
    184179            } 
    185180            else { 
    … …  
    200195     * @param requiredEqualityLevel 
    201196     */ 
    202     private boolean checkEqualityLevel(List<ITaskTreeNode> children1, 
    203                                        List<ITaskTreeNode> children2, 
    204                                        NodeEquality        requiredEqualityLevel) 
     197    private boolean checkEqualityLevel(List<ITask> children1, 
     198                                       List<ITask> children2, 
     199                                       TaskEquality requiredEqualityLevel) 
    205200    { 
    206         NodeEquality childEquality; 
    207         NodeEquality currentEquality; 
    208         for (ITaskTreeNode child1 : children1) { 
     201        TaskEquality childEquality; 
     202        TaskEquality currentEquality; 
     203        for (ITask child1 : children1) { 
    209204            childEquality = null; 
    210             for (ITaskTreeNode child2 : children2) { 
     205            for (ITask child2 : children2) { 
    211206                currentEquality = callRuleManager(child1, child2, requiredEqualityLevel); 
    212207                if ((currentEquality != null) && (currentEquality.isAtLeast(requiredEqualityLevel))) 
    … …  
    240235     * @return 
    241236     */ 
    242     private NodeEquality callRuleManager(ITaskTreeNode child1, 
    243                                          ITaskTreeNode child2, 
    244                                          NodeEquality requiredEqualityLevel) 
     237    private TaskEquality callRuleManager(ITask        child1, 
     238                                         ITask        child2, 
     239                                         TaskEquality requiredEqualityLevel) 
    245240    { 
    246241        if (requiredEqualityLevel == null) { 
    … …  
    251246        } 
    252247        else { 
    253             return NodeEquality.UNEQUAL; 
     248            return TaskEquality.UNEQUAL; 
    254249        } 
    255250    } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SequenceComparisonRule.java

    r1125 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1616 
    1717import java.util.List; 
    1818 
    1919import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    20 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     20import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2121 
    2222/** 
    … …  
    3131 * @author 2012, last modified by $Author: patrick$ 
    3232 */ 
    33 public class SequenceComparisonRule implements NodeComparisonRule { 
     33public class SequenceComparisonRule implements TaskComparisonRule { 
    3434 
    35     /** the rule manager for internally comparing task tree nodes */ 
    36     private NodeEqualityRuleManager mRuleManager; 
     35    /** the rule manager for internally comparing tasks */ 
     36    private TaskEqualityRuleManager mRuleManager; 
    3737 
    3838    /** 
    3939     * <p> 
    40      * simple constructor to provide the rule with the node equality rule manager to be able 
    41      * to perform comparisons of the children of provided task tree nodes 
     40     * simple constructor to provide the rule with the task equality rule manager to be able 
     41     * to perform comparisons of the children of provided tasks 
    4242     * </p> 
    4343     *  
    44      * @param ruleManager the rule manager for comparing task tree nodes 
     44     * @param ruleManager the rule manager for comparing tasks 
    4545     */ 
    46     SequenceComparisonRule(NodeEqualityRuleManager ruleManager) { 
     46    SequenceComparisonRule(TaskEqualityRuleManager ruleManager) { 
    4747        super(); 
    4848        mRuleManager = ruleManager; 
    … …  
    5050 
    5151    /* (non-Javadoc) 
    52      * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode) 
     52     * @see NodeComparisonRule#isApplicable(ITask, ITask) 
    5353     */ 
    5454    @Override 
    55     public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) { 
    56         return (node1 instanceof ISequence) && (node2 instanceof ISequence); 
     55    public boolean isApplicable(ITask task1, ITask task2) { 
     56        return (task1 instanceof ISequence) && (task2 instanceof ISequence); 
    5757    } 
    5858 
    5959    /* (non-Javadoc) 
    60      * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode) 
     60     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask) 
    6161     */ 
    6262    @Override 
    63     public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    64         NodeEquality equality = getEquality(node1, node2, NodeEquality.LEXICALLY_EQUAL); 
    65         return (equality != null) && (equality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); 
     63    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     64        TaskEquality equality = getEquality(task1, task2, TaskEquality.LEXICALLY_EQUAL); 
     65        return (equality != null) && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); 
    6666    } 
    6767 
    6868    /* (non-Javadoc) 
    69      * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     69     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask) 
    7070     */ 
    7171    @Override 
    72     public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    73         NodeEquality equality = getEquality(node1, node2, NodeEquality.SYNTACTICALLY_EQUAL); 
    74         return (equality != null) && (equality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); 
     72    public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     73        TaskEquality equality = getEquality(task1, task2, TaskEquality.SYNTACTICALLY_EQUAL); 
     74        return (equality != null) && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); 
    7575    } 
    7676 
    7777    /* (non-Javadoc) 
    78      * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     78     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask) 
    7979     */ 
    8080    @Override 
    81     public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    82         NodeEquality equality = getEquality(node1, node2, NodeEquality.SEMANTICALLY_EQUAL); 
    83         return (equality != null) && (equality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); 
     81    public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     82        TaskEquality equality = getEquality(task1, task2, TaskEquality.SEMANTICALLY_EQUAL); 
     83        return (equality != null) && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); 
    8484    } 
    8585 
    8686    /* (non-Javadoc) 
    87      * @see NodeComparisonRule#compare(ITaskTreeNode, ITaskTreeNode) 
     87     * @see NodeComparisonRule#compare(ITask, ITask) 
    8888     */ 
    8989    @Override 
    90     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    91         return getEquality(node1, node2, null); 
     90    public TaskEquality compare(ITask task1, ITask task2) { 
     91        return getEquality(task1, task2, null); 
    9292    } 
    9393 
    … …  
    9595     *  
    9696     */ 
    97     private NodeEquality getEquality(ITaskTreeNode node1, 
    98                                      ITaskTreeNode node2, 
    99                                      NodeEquality  requiredEqualityLevel) 
    100     { 
    101         List<ITaskTreeNode> children1 = node1.getChildren(); 
    102         List<ITaskTreeNode> children2 = node2.getChildren(); 
     97    private TaskEquality getEquality(ITask task1, ITask task2, TaskEquality requiredEqualityLevel) { 
     98        List<ITask> children1 = ((ISequence) task1).getChildren(); 
     99        List<ITask> children2 = ((ISequence) task2).getChildren(); 
    103100 
    104101        // if both sequences do not have children, they are equal although this doesn't make sense 
    105102        if ((children1.size() == 0) && (children2.size() == 0)) { 
    106             return NodeEquality.LEXICALLY_EQUAL; 
     103            return TaskEquality.LEXICALLY_EQUAL; 
    107104        } 
    108105 
    109106        if (children1.size() != children2.size()) { 
    110             return NodeEquality.UNEQUAL; 
     107            return TaskEquality.UNEQUAL; 
    111108        } 
    112109 
    113         NodeEquality resultingEquality = NodeEquality.LEXICALLY_EQUAL; 
     110        TaskEquality resultingEquality = TaskEquality.LEXICALLY_EQUAL; 
    114111        for (int i = 0; i < children1.size(); i++) { 
    115             ITaskTreeNode child1 = children1.get(i); 
    116             ITaskTreeNode child2 = children2.get(i); 
     112            ITask child1 = children1.get(i); 
     113            ITask child2 = children2.get(i); 
    117114 
    118             NodeEquality nodeEquality = callRuleManager(child1, child2, requiredEqualityLevel); 
     115            TaskEquality taskEquality = callRuleManager(child1, child2, requiredEqualityLevel); 
    119116 
    120             if ((nodeEquality == null) || (nodeEquality == NodeEquality.UNEQUAL)) { 
    121                 return NodeEquality.UNEQUAL; 
     117            if ((taskEquality == null) || (taskEquality == TaskEquality.UNEQUAL)) { 
     118                return TaskEquality.UNEQUAL; 
    122119            } 
    123120             
    124             resultingEquality = resultingEquality.getCommonDenominator(nodeEquality); 
     121            resultingEquality = resultingEquality.getCommonDenominator(taskEquality); 
    125122        } 
    126123 
    … …  
    138135     * @return 
    139136     */ 
    140     private NodeEquality callRuleManager(ITaskTreeNode child1, 
    141                                          ITaskTreeNode child2, 
    142                                          NodeEquality requiredEqualityLevel) 
     137    private TaskEquality callRuleManager(ITask        child1, 
     138                                         ITask        child2, 
     139                                         TaskEquality requiredEqualityLevel) 
    143140    { 
    144141        if (requiredEqualityLevel == null) { 
    … …  
    149146        } 
    150147        else { 
    151             return NodeEquality.UNEQUAL; 
     148            return TaskEquality.UNEQUAL; 
    152149        } 
    153150    } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndIterationComparisonRule.java

    r1125 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
    16  
    17 import java.util.List; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1816 
    1917import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration; 
    20 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     18import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2119 
    2220/** 
    2321 * <p> 
    24  * This class is capable of comparing any task tree node which is not an iteration with an 
    25  * iteration. This is needed, because iterations may iterate exactly that node. In this 
    26  * case, the iteration would be equal to that node if it was executed exactly once. The rule 
    27  * returns lexically equal, it the child of the iteration is lexically equal to the node 
     22 * This class is capable of comparing any task which is not an iteration with an 
     23 * iteration. This is needed, because iterations may iterate exactly that task. In this 
     24 * case, the iteration would be equal to that task if it was executed exactly once. The rule 
     25 * returns lexically equal, it the child of the iteration is lexically equal to the task 
    2826 * or if the child of the iteration is a selection and this selections contains a lexically equal 
    29  * node. The same applies for syntactical and semantical equality. 
     27 * task. The same applies for syntactical and semantical equality. 
    3028 * </p> 
    3129 
    3230 * @author Patrick Harms 
    3331 */ 
    34 public class NodeAndIterationComparisonRule implements NodeComparisonRule { 
     32public class TaskAndIterationComparisonRule implements TaskComparisonRule { 
    3533     
    36     /** the rule manager for internally comparing task tree nodes */ 
    37     private NodeEqualityRuleManager mRuleManager; 
     34    /** the rule manager for internally comparing tasks */ 
     35    private TaskEqualityRuleManager mRuleManager; 
    3836 
    3937    /** 
    4038     * <p> 
    41      * simple constructor to provide the rule with the node equality rule manager to be able 
    42      * to perform comparisons of the children of provided task tree nodes 
     39     * simple constructor to provide the rule with the task equality rule manager to be able 
     40     * to perform comparisons of the children of provided tasks 
    4341     * </p> 
    4442     *  
    45      * @param ruleManager the rule manager for comparing task tree nodes 
     43     * @param ruleManager the rule manager for comparing tasks 
    4644     */ 
    47     NodeAndIterationComparisonRule(NodeEqualityRuleManager ruleManager) { 
     45    TaskAndIterationComparisonRule(TaskEqualityRuleManager ruleManager) { 
    4846        super(); 
    4947        mRuleManager = ruleManager; 
    … …  
    5149 
    5250    /* (non-Javadoc) 
    53      * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode) 
     51     * @see NodeComparisonRule#isApplicable(ITask, ITask) 
    5452     */ 
    5553    @Override 
    56     public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) { 
    57         return ((node1 instanceof IIteration) && (!(node2 instanceof IIteration))) || 
    58                ((node2 instanceof IIteration) && (!(node1 instanceof IIteration))); 
     54    public boolean isApplicable(ITask task1, ITask task2) { 
     55        return ((task1 instanceof IIteration) && (!(task2 instanceof IIteration))) || 
     56               ((task2 instanceof IIteration) && (!(task1 instanceof IIteration))); 
    5957    } 
    6058 
    6159    /* (non-Javadoc) 
    62      * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode) 
     60     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask) 
    6361     */ 
    6462    @Override 
    65     public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    66         NodeEquality equality = getEquality(node1, node2, NodeEquality.LEXICALLY_EQUAL); 
    67         return (equality != null) && (equality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); 
     63    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     64        TaskEquality equality = getEquality(task1, task2, TaskEquality.LEXICALLY_EQUAL); 
     65        return (equality != null) && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); 
    6866    } 
    6967 
    7068    /* (non-Javadoc) 
    71      * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     69     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask) 
    7270     */ 
    7371    @Override 
    74     public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    75         NodeEquality equality = getEquality(node1, node2, NodeEquality.SYNTACTICALLY_EQUAL); 
    76         return (equality != null) && (equality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); 
     72    public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     73        TaskEquality equality = getEquality(task1, task2, TaskEquality.SYNTACTICALLY_EQUAL); 
     74        return (equality != null) && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); 
    7775    } 
    7876 
    7977    /* (non-Javadoc) 
    80      * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     78     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask) 
    8179     */ 
    8280    @Override 
    83     public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    84         NodeEquality equality = getEquality(node1, node2, NodeEquality.SEMANTICALLY_EQUAL); 
    85         return (equality != null) && (equality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); 
     81    public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     82        TaskEquality equality = getEquality(task1, task2, TaskEquality.SEMANTICALLY_EQUAL); 
     83        return (equality != null) && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); 
    8684    } 
    8785 
    8886    /* (non-Javadoc) 
    89      * @see NodeComparisonRule#compare(ITaskTreeNode, ITaskTreeNode) 
     87     * @see NodeComparisonRule#compare(ITask, ITask) 
    9088     */ 
    9189    @Override 
    92     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    93         return getEquality(node1, node2, null); 
     90    public TaskEquality compare(ITask task1, ITask task2) { 
     91        return getEquality(task1, task2, null); 
    9492    } 
    9593 
    … …  
    9795     *  
    9896     */ 
    99     private NodeEquality getEquality(ITaskTreeNode node1, 
    100                                      ITaskTreeNode node2, 
    101                                      NodeEquality  requiredEqualityLevel) 
    102     { 
     97    private TaskEquality getEquality(ITask task1, ITask task2, TaskEquality requiredEqualityLevel) { 
    10398        IIteration iteration = null; 
    104         ITaskTreeNode node = null; 
     99        ITask task = null; 
    105100         
    106         if (node1 instanceof IIteration) { 
    107             if (node2 instanceof IIteration) { 
     101        if (task1 instanceof IIteration) { 
     102            if (task2 instanceof IIteration) { 
    108103                // the rule is not responsible for two iterations 
    109104                return null; 
    110105            } 
    111106             
    112             iteration = (IIteration) node1; 
    113             node = node2; 
     107            iteration = (IIteration) task1; 
     108            task = task2; 
    114109        } 
    115         else if (node2 instanceof IIteration) { 
    116             if (node1 instanceof IIteration) { 
     110        else if (task2 instanceof IIteration) { 
     111            if (task1 instanceof IIteration) { 
    117112                // the rule is not responsible for two iterations 
    118113                return null; 
    119114            } 
    120115             
    121             iteration = (IIteration) node2; 
    122             node = node1; 
     116            iteration = (IIteration) task2; 
     117            task = task1; 
    123118        } 
    124119        else { 
    … …  
    126121        } 
    127122 
    128         List<ITaskTreeNode> children = iteration.getChildren(); 
     123        ITask child = iteration.getMarkedTask(); 
    129124         
    130         // now, that we found the iteration and the node, lets compare the child of the iteration 
    131         // with the node. 
    132         if (children.size() < 1) { 
     125        // now, that we found the iteration and the task, lets compare the child of the iteration 
     126        // with the task. 
     127        if (child == null) { 
    133128            return null; 
    134129        } 
    135130 
    136         NodeEquality nodeEquality = callRuleManager(children.get(0), node, requiredEqualityLevel); 
     131        TaskEquality taskEquality = callRuleManager(child, task, requiredEqualityLevel); 
    137132 
    138         // although the subtask may be identical to the node, we can not return identical, as 
    139         // the iteration is not identical to the node, but at most lexically equal 
    140         if (nodeEquality == NodeEquality.IDENTICAL) { 
    141             return NodeEquality.LEXICALLY_EQUAL; 
     133        // although the subtask may be identical to the task, we can not return identical, as 
     134        // the iteration is not identical to the task, but at most lexically equal 
     135        if (taskEquality == TaskEquality.IDENTICAL) { 
     136            return TaskEquality.LEXICALLY_EQUAL; 
    142137        } 
    143138        else { 
    144             return nodeEquality; 
     139            return taskEquality; 
    145140        } 
    146141 
    … …  
    157152     * @return 
    158153     */ 
    159     private NodeEquality callRuleManager(ITaskTreeNode child1, 
    160                                          ITaskTreeNode child2, 
    161                                          NodeEquality requiredEqualityLevel) 
     154    private TaskEquality callRuleManager(ITask        child1, 
     155                                         ITask        child2, 
     156                                         TaskEquality requiredEqualityLevel) 
    162157    { 
    163158        if (requiredEqualityLevel == null) { 
    … …  
    168163        } 
    169164        else { 
    170             return NodeEquality.UNEQUAL; 
     165            return TaskEquality.UNEQUAL; 
    171166        } 
    172167    } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndSelectionComparisonRule.java

    r1125 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1616 
    1717import java.util.List; 
    1818 
    1919import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; 
    20 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     20import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2121 
    2222/** 
    2323 * <p> 
    24  * This class is capable of comparing any task tree node which is not a selection with a 
    25  * selection. This is needed, because selections may contain exactly that node. Therefore, if 
    26  * this node is selected out of a selection the selection is equal to the node itself.  
    27  * The rule returns lexically equal, it the selection contains a lexically equal node. The same 
     24 * This class is capable of comparing any task which is not a selection with a 
     25 * selection. This is needed, because selections may contain exactly that task. Therefore, if 
     26 * this task is selected out of a selection the selection is equal to the task itself.  
     27 * The rule returns lexically equal, if the selection contains a lexically equal task. The same 
    2828 * applies for syntactical and semantical equality. 
    2929 * </p> 
    … …  
    3131 * @author Patrick Harms 
    3232 */ 
    33 public class NodeAndSelectionComparisonRule implements NodeComparisonRule { 
     33public class TaskAndSelectionComparisonRule implements TaskComparisonRule { 
    3434     
    35     /** the rule manager for internally comparing task tree nodes */ 
    36     private NodeEqualityRuleManager mRuleManager; 
     35    /** the rule manager for internally comparing tasks */ 
     36    private TaskEqualityRuleManager mRuleManager; 
    3737     
    3838    /** 
    3939     * <p> 
    40      * simple constructor to provide the rule with the node equality rule manager to be able 
    41      * to perform comparisons of the children of provided task tree nodes 
     40     * simple constructor to provide the rule with the task equality rule manager to be able 
     41     * to perform comparisons of the children of provided tasks 
    4242     * </p> 
    4343     *  
    44      * @param ruleManager the rule manager for comparing task tree nodes 
     44     * @param ruleManager the rule manager for comparing tasks 
    4545     */ 
    46     NodeAndSelectionComparisonRule(NodeEqualityRuleManager ruleManager) { 
     46    TaskAndSelectionComparisonRule(TaskEqualityRuleManager ruleManager) { 
    4747        super(); 
    4848        mRuleManager = ruleManager; 
    … …  
    5050 
    5151    /* (non-Javadoc) 
    52      * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode) 
     52     * @see NodeComparisonRule#isApplicable(ITask, ITask) 
    5353     */ 
    5454    @Override 
    55     public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) { 
    56         return ((node1 instanceof ISelection) && (!(node2 instanceof ISelection))) || 
    57                ((node2 instanceof ISelection) && (!(node1 instanceof ISelection))); 
     55    public boolean isApplicable(ITask task1, ITask task2) { 
     56        return ((task1 instanceof ISelection) && (!(task2 instanceof ISelection))) || 
     57               ((task2 instanceof ISelection) && (!(task1 instanceof ISelection))); 
    5858    } 
    5959 
    6060    /* (non-Javadoc) 
    61      * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode) 
     61     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask) 
    6262     */ 
    6363    @Override 
    64     public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    65         NodeEquality equality = getEquality(node1, node2, NodeEquality.LEXICALLY_EQUAL); 
    66         return (equality != null) && (equality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); 
     64    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     65        TaskEquality equality = getEquality(task1, task2, TaskEquality.LEXICALLY_EQUAL); 
     66        return (equality != null) && (equality.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); 
    6767    } 
    6868 
    6969    /* (non-Javadoc) 
    70      * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     70     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask) 
    7171     */ 
    7272    @Override 
    73     public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    74         NodeEquality equality = getEquality(node1, node2, NodeEquality.SYNTACTICALLY_EQUAL); 
    75         return (equality != null) && (equality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); 
     73    public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     74        TaskEquality equality = getEquality(task1, task2, TaskEquality.SYNTACTICALLY_EQUAL); 
     75        return (equality != null) && (equality.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); 
    7676    } 
    7777 
    7878    /* (non-Javadoc) 
    79      * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     79     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask) 
    8080     */ 
    8181    @Override 
    82     public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    83         NodeEquality equality = getEquality(node1, node2, NodeEquality.SEMANTICALLY_EQUAL); 
    84         return (equality != null) && (equality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); 
     82    public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     83        TaskEquality equality = getEquality(task1, task2, TaskEquality.SEMANTICALLY_EQUAL); 
     84        return (equality != null) && (equality.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); 
    8585    } 
    8686 
    8787    /* (non-Javadoc) 
    88      * @see NodeComparisonRule#compare(ITaskTreeNode, ITaskTreeNode) 
     88     * @see NodeComparisonRule#compare(ITask, ITask) 
    8989     */ 
    9090    @Override 
    91     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    92         return getEquality(node1, node2, null); 
     91    public TaskEquality compare(ITask task1, ITask task2) { 
     92        return getEquality(task1, task2, null); 
    9393    } 
    9494     
    … …  
    9696     *  
    9797     */ 
    98     private NodeEquality getEquality(ITaskTreeNode node1, 
    99                                      ITaskTreeNode node2, 
    100                                      NodeEquality  requiredEqualityLevel) 
    101     { 
     98    private TaskEquality getEquality(ITask task1, ITask task2, TaskEquality requiredEqualityLevel) { 
    10299        ISelection selection = null; 
    103         ITaskTreeNode node = null; 
     100        ITask task = null; 
    104101         
    105         if (node1 instanceof ISelection) { 
    106             if (node2 instanceof ISelection) { 
     102        if (task1 instanceof ISelection) { 
     103            if (task2 instanceof ISelection) { 
    107104                // the rule is not responsible for two selections 
    108105                return null; 
    109106            } 
    110107             
    111             selection = (ISelection) node1; 
    112             node = node2; 
     108            selection = (ISelection) task1; 
     109            task = task2; 
    113110        } 
    114         else if (node2 instanceof ISelection) { 
    115             if (node1 instanceof ISelection) { 
     111        else if (task2 instanceof ISelection) { 
     112            if (task1 instanceof ISelection) { 
    116113                // the rule is not responsible for two selections 
    117114                return null; 
    118115            } 
    119116             
    120             selection = (ISelection) node2; 
    121             node = node1; 
     117            selection = (ISelection) task2; 
     118            task = task1; 
    122119        } 
    123120        else { 
    … …  
    125122        } 
    126123 
    127         // now, that we found the selection and the node, lets compare the children of the selection 
    128         // with the node. 
    129         List<ITaskTreeNode> children = selection.getChildren(); 
     124        // now, that we found the selection and the task, lets compare the children of the selection 
     125        // with the task. 
     126        List<ITask> children = selection.getChildren(); 
    130127         
    131128        if (children.size() < 1) { 
    … …  
    133130        } 
    134131 
    135         NodeEquality mostConcreteNodeEquality = null; 
     132        TaskEquality mostConcreteNodeEquality = null; 
    136133         
    137         for (ITaskTreeNode child : children) { 
    138             NodeEquality nodeEquality = callRuleManager(child, node, requiredEqualityLevel); 
     134        for (ITask child : children) { 
     135            TaskEquality taskEquality = callRuleManager(child, task, requiredEqualityLevel); 
    139136             
    140             if (nodeEquality != NodeEquality.UNEQUAL) { 
     137            if (taskEquality != TaskEquality.UNEQUAL) { 
    141138                if (mostConcreteNodeEquality == null) { 
    142                     mostConcreteNodeEquality = nodeEquality; 
     139                    mostConcreteNodeEquality = taskEquality; 
    143140                } 
    144                 else if (mostConcreteNodeEquality.isAtLeast(nodeEquality)) { 
    145                     mostConcreteNodeEquality = nodeEquality; 
     141                else if (mostConcreteNodeEquality.isAtLeast(taskEquality)) { 
     142                    mostConcreteNodeEquality = taskEquality; 
    146143                     
    147144                } 
    … …  
    151148                { 
    152149                    // if we found one child of the selection that is as equal as required, then 
    153                     // we can consider the selection to be sufficiently equal to the other node. 
     150                    // we can consider the selection to be sufficiently equal to the other task. 
    154151                    // So we break up checking further children. 
    155152                    break; 
    … …  
    158155        } 
    159156         
    160         // although the subtask may be identical to the node, we can not return identical, as 
    161         // the selection is not identical to the node, but at most lexically equal 
    162         if (mostConcreteNodeEquality == NodeEquality.IDENTICAL) { 
    163             return NodeEquality.LEXICALLY_EQUAL; 
     157        // although the subtask may be identical to the task, we can not return identical, as 
     158        // the selection is not identical to the task, but at most lexically equal 
     159        if (mostConcreteNodeEquality == TaskEquality.IDENTICAL) { 
     160            return TaskEquality.LEXICALLY_EQUAL; 
    164161        } 
    165162        else { 
    … …  
    179176     * @return 
    180177     */ 
    181     private NodeEquality callRuleManager(ITaskTreeNode child1, 
    182                                          ITaskTreeNode child2, 
    183                                          NodeEquality requiredEqualityLevel) 
     178    private TaskEquality callRuleManager(ITask        child1, 
     179                                         ITask        child2, 
     180                                         TaskEquality requiredEqualityLevel) 
    184181    { 
    185182        if (requiredEqualityLevel == null) { 
    … …  
    190187        } 
    191188        else { 
    192             return NodeEquality.UNEQUAL; 
     189            return TaskEquality.UNEQUAL; 
    193190        } 
    194191    } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskComparator.java

    r1129 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.temporalrelation; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1616 
    1717import java.util.HashMap; 
    1818 
    19 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; 
    20 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager; 
    21 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     19import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
     20import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
    2221import de.ugoe.cs.autoquest.usageprofiles.SymbolComparator; 
    2322import de.ugoe.cs.util.StopWatch; 
    … …  
    3029 * @author Patrick Harms 
    3130 */ 
    32 public class TaskTreeNodeComparator implements SymbolComparator<ITaskTreeNode> { 
     31public class TaskComparator implements SymbolComparator<ITaskInstance> { 
    3332     
    3433    /** 
    3534     * <p> 
    36      * the node equality manager needed for comparing task tree nodes with each other 
     35     * the task equality manager needed for comparing tasks with each other 
    3736     * </p> 
    3837     */ 
    39     private NodeEqualityRuleManager nodeEqualityRuleManager; 
     38    private TaskEqualityRuleManager taskEqualityRuleManager; 
    4039 
    4140    /** 
    4241     * <p> 
    43      * the minimal node equality two identified sublists need to have to consider them as equal 
    44      * and to create an iteration for 
     42     * the minimal task equality two identified sublists need to have to consider them as equal 
    4543     * </p> 
    4644     */ 
    47     private NodeEquality minimalNodeEquality; 
    48  
     45    private TaskEquality minimalNodeEquality; 
     46 
     47    /** */ 
    4948    private Comparer comparer; 
    5049 
     50    /** */ 
    5151    private Comparer lexicalComparer; 
    5252 
     53    /** */ 
    5354    private StopWatch stopWatch = new StopWatch(); 
    5455     
     56    /** */ 
    5557    private HashMap<Long, Boolean> equalityBuffer = new HashMap<Long, Boolean>(); 
    5658 
     59    /** */ 
    5760    private HashMap<Long, Boolean> lexicalEqualityBuffer; 
    5861 
    5962    /** 
    60      * <p> 
    61      * TODO: comment 
    62      * </p> 
    63      * 
    64      * @param nodeEqualityRuleManager 
    65      * @param minimalNodeEquality 
    66      */ 
    67     public TaskTreeNodeComparator(NodeEqualityRuleManager nodeEqualityRuleManager, 
    68                                   NodeEquality            minimalNodeEquality) 
     63     * 
     64     */ 
     65    public TaskComparator(TaskEqualityRuleManager taskEqualityRuleManager, 
     66                                  TaskEquality            minimalNodeEquality) 
    6967    { 
    7068        super(); 
    71         this.nodeEqualityRuleManager = nodeEqualityRuleManager; 
     69        this.taskEqualityRuleManager = taskEqualityRuleManager; 
    7270        this.minimalNodeEquality = minimalNodeEquality; 
    7371         
    74         if (minimalNodeEquality == NodeEquality.LEXICALLY_EQUAL) { 
     72        if (minimalNodeEquality == TaskEquality.LEXICALLY_EQUAL) { 
    7573            comparer = new LexicalComparer(); 
    7674        } 
    77         else if (minimalNodeEquality == NodeEquality.SYNTACTICALLY_EQUAL) { 
     75        else if (minimalNodeEquality == TaskEquality.SYNTACTICALLY_EQUAL) { 
    7876            comparer = new SyntacticalComparer(); 
    7977        } 
    80         else if (minimalNodeEquality == NodeEquality.SEMANTICALLY_EQUAL) { 
     78        else if (minimalNodeEquality == TaskEquality.SEMANTICALLY_EQUAL) { 
    8179            comparer = new SemanticalComparer(); 
    8280        } 
    … …  
    8583        } 
    8684         
    87         if (minimalNodeEquality == NodeEquality.LEXICALLY_EQUAL) { 
     85        if (minimalNodeEquality == TaskEquality.LEXICALLY_EQUAL) { 
    8886            lexicalComparer = comparer; 
    8987            lexicalEqualityBuffer = equalityBuffer; 
    … …  
    9997     */ 
    10098    @Override 
    101     public boolean equals(ITaskTreeNode symbol1, ITaskTreeNode symbol2) { 
    102         //String id = "compare " + symbol1.getClass().getSimpleName() + " " + 
    103         //    symbol2.getClass().getSimpleName(); 
     99    public boolean equals(ITaskInstance taskInstance1, ITaskInstance taskInstance2) { 
     100        return equals(taskInstance1.getTask(), taskInstance2.getTask()); 
     101    }         
     102 
     103    /** 
     104     *  
     105     */ 
     106    public boolean equals(ITask task1, ITask task2) { 
     107        //String id = "compare " + taskInstance1.getClass().getSimpleName() + " " + 
     108        //    taskInstance2.getClass().getSimpleName(); 
    104109        //String id = "compare"; 
    105110        //stopWatch.start(id); 
    … …  
    107112        Boolean result; 
    108113         
    109         if (symbol1 != symbol2) { 
    110             long key = ((long) System.identityHashCode(symbol1)) << 32; 
    111             key += System.identityHashCode(symbol2); 
     114        if (task1 != task2) { 
     115            long key = ((long) System.identityHashCode(task1)) << 32; 
     116            key += System.identityHashCode(task2); 
    112117             
    113118            result = equalityBuffer.get(key); 
    114119             
    115120            if (result == null) { 
    116                 result = comparer.compare(symbol1, symbol2); 
     121                result = comparer.compare(task1, task2); 
    117122                equalityBuffer.put(key, result); 
    118123            } 
    … …  
    123128        //stopWatch.stop(id); 
    124129         
    125         /*boolean result2 = nodeEqualityRuleManager.areAtLeastEqual(symbol1, symbol2, minimalNodeEquality); 
     130        /*boolean result2 = taskEqualityRuleManager.areAtLeastEqual(symbol1, symbol2, minimalNodeEquality); 
    126131        if (result != result2) { 
    127132            throw new IllegalStateException("implementation error"); 
    … …  
    132137 
    133138    /** 
    134      * <p> 
    135      * TODO: comment 
    136      * </p> 
    137      * 
    138      * @return 
     139     * 
     140     */ 
     141    public boolean haveLexicallyEqualTasks(ITaskInstance taskInstance1, 
     142                                           ITaskInstance taskInstance2) 
     143    { 
     144        return areLexicallyEqual(taskInstance1.getTask(), taskInstance2.getTask()); 
     145    } 
     146         
     147 
     148    /** 
     149     * 
     150     */ 
     151    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     152        Boolean result; 
     153         
     154        if (task1 != task2) { 
     155            long key = ((long) System.identityHashCode(task1)) << 32; 
     156            key += System.identityHashCode(task2); 
     157             
     158            result = lexicalEqualityBuffer.get(key); 
     159             
     160            if (result == null) { 
     161                result = lexicalComparer.compare(task1, task2); 
     162                lexicalEqualityBuffer.put(key, result); 
     163            } 
     164        } 
     165        else { 
     166            result = true; 
     167        } 
     168         
     169        return result; 
     170    } 
     171 
     172    /** 
     173     * 
    139174     */ 
    140175    StopWatch getStopWatch() { 
    … …  
    143178 
    144179    /** 
    145      * <p> 
    146      * TODO: comment 
    147      * </p> 
    148      * 
    149      * @param node1 
    150      * @param node2 
    151      * @return 
    152      */ 
    153     boolean areLexicallyEqual(ITaskTreeNode symbol1, ITaskTreeNode symbol2) { 
    154         Boolean result; 
    155          
    156         if (symbol1 != symbol2) { 
    157             long key = ((long) System.identityHashCode(symbol1)) << 32; 
    158             key += System.identityHashCode(symbol2); 
    159              
    160             result = lexicalEqualityBuffer.get(key); 
    161              
    162             if (result == null) { 
    163                 result = lexicalComparer.compare(symbol1, symbol2); 
    164                 lexicalEqualityBuffer.put(key, result); 
    165             } 
    166         } 
    167         else { 
    168             result = true; 
    169         } 
    170          
    171         return result; 
    172     } 
    173  
    174     /** 
    175      * <p> 
    176      * TODO: comment 
    177      * </p> 
    178      * 
    179      * @return 
    180      */ 
    181     NodeEquality getConsideredNodeEquality() { 
     180     * 
     181     */ 
     182    TaskEquality getConsideredNodeEquality() { 
    182183        return minimalNodeEquality; 
    183184    } 
    … …  
    190191         *  
    191192         */ 
    192         boolean compare(ITaskTreeNode node1, ITaskTreeNode node2); 
     193        boolean compare(ITask task1, ITask task2); 
    193194    } 
    194195 
    … …  
    201202         *  
    202203         */ 
    203         public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    204             return nodeEqualityRuleManager.areLexicallyEqual(node1, node2); 
     204        public boolean compare(ITask task1, ITask task2) { 
     205            return taskEqualityRuleManager.areLexicallyEqual(task1, task2); 
    205206        } 
    206207    } 
    … …  
    214215         *  
    215216         */ 
    216         public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    217             return nodeEqualityRuleManager.areSyntacticallyEqual(node1, node2); 
     217        public boolean compare(ITask task1, ITask task2) { 
     218            return taskEqualityRuleManager.areSyntacticallyEqual(task1, task2); 
    218219        } 
    219220    } 
    … …  
    227228         *  
    228229         */ 
    229         public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    230             return nodeEqualityRuleManager.areSemanticallyEqual(node1, node2); 
     230        public boolean compare(ITask task1, ITask task2) { 
     231            return taskEqualityRuleManager.areSemanticallyEqual(task1, task2); 
    231232        } 
    232233    } 
    … …  
    240241         *  
    241242         */ 
    242         public boolean compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    243             return nodeEqualityRuleManager.areAtLeastEqual(node1, node2, minimalNodeEquality); 
     243        public boolean compare(ITask task1, ITask task2) { 
     244            return taskEqualityRuleManager.areAtLeastEqual(task1, task2, minimalNodeEquality); 
    244245        } 
    245246    } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskComparisonRule.java

    r1125 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1616 
    17 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     17import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    1818 
    1919/** 
    2020 * <p> 
    21  * A node comparison rule is used by the {@link NodeEqualityRuleManager} to compare task tree 
    22  * nodes with each other. It provides one method to be called for a comparison. 
     21 * A task comparison rule is used by the {@link TaskEqualityRuleManager} to compare tasks with 
     22 * each other. It provides several methods to be called for a comparison. 
    2323 * </p> 
    2424 *  
    … …  
    2626 * @author 2012, last modified by $Author: patrick$ 
    2727 */ 
    28 public interface NodeComparisonRule { 
     28public interface TaskComparisonRule { 
    2929 
    3030    /** 
    3131     * <p> 
    32      * checks if the rule is applicable for comparing the two provided nodes 
     32     * checks if the rule is applicable for comparing the two provided tasks 
    3333     * </p> 
    3434     *  
    35      * @param node1 the first task tree node to compare 
    36      * @param node2 the second task tree node to compare 
     35     * @param task1 the first task to compare 
     36     * @param task2 the second task to compare 
    3737     *  
    3838     * @return true, if the rule is applicable, false else 
    3939     */ 
    40     public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2); 
     40    public boolean isApplicable(ITask task1, ITask task2); 
    4141 
    4242    /** 
    4343     * <p> 
    44      * checks, if the provided nodes are lexically equal 
     44     * checks, if the provided tasks are lexically equal 
    4545     * </p> 
    4646     *  
    47      * @param node1 the first task tree node to compare 
    48      * @param node2 the second task tree node to compare 
     47     * @param task1 the first task to compare 
     48     * @param task2 the second task to compare 
    4949     *  
    50      * @return true, if the nodes are equal, false else 
     50     * @return true, if the tasks are equal, false else 
    5151     */ 
    52     public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2); 
     52    public boolean areLexicallyEqual(ITask task1, ITask task2); 
    5353 
    5454    /** 
    5555     * <p> 
    56      * checks, if the provided nodes are syntactically equal 
     56     * checks, if the provided tasks are syntactically equal 
    5757     * </p> 
    5858     *  
    59      * @param node1 the first task tree node to compare 
    60      * @param node2 the second task tree node to compare 
     59     * @param task1 the first task to compare 
     60     * @param task2 the second task to compare 
    6161     *  
    62      * @return true, if the nodes are equal, false else 
     62     * @return true, if the tasks are equal, false else 
    6363     */ 
    64     public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2); 
     64    public boolean areSyntacticallyEqual(ITask task1, ITask task2); 
    6565 
    6666    /** 
    6767     * <p> 
    68      * checks, if the provided nodes are semantically equal 
     68     * checks, if the provided tasks are semantically equal 
    6969     * </p> 
    7070     *  
    71      * @param node1 the first task tree node to compare 
    72      * @param node2 the second task tree node to compare 
     71     * @param task1 the first task to compare 
     72     * @param task2 the second task to compare 
    7373     *  
    74      * @return true, if the nodes are equal, false else 
     74     * @return true, if the tasks are equal, false else 
    7575     */ 
    76     public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2); 
     76    public boolean areSemanticallyEqual(ITask task1, ITask task2); 
    7777 
    7878    /** 
    7979     * <p> 
    80      * compares two nodes with each other. The result of the method is either a node equality or 
     80     * compares two tasks with each other. The result of the method is either a task equality or 
    8181     * null. If it is null, it means, that the rule is not able to correctly compare the two given 
    82      * nodes 
     82     * tasks 
    8383     * </p> 
    8484     *  
    85      * @param node1 the first task tree node to compare 
    86      * @param node2 the second task tree node to compare 
     85     * @param task1 the first task to compare 
     86     * @param task2 the second task to compare 
    8787     *  
    8888     * @return as described 
    8989     */ 
    90     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2); 
     90    public TaskEquality compare(ITask task1, ITask task2); 
    9191 
    9292} 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskEquality.java

    r1113 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1616 
    1717/** 
    1818 * <p> 
    19  * A node equality denotes, how equal two task tree nodes are. There are different equality levels 
     19 * A task equality denotes, how equal two tasks are. There are different equality levels 
    2020 * which are similar to the usual design levels of GUI design. These levels are 
    2121 * <ul> 
    … …  
    2626 *       can be performed</li> 
    2727 * </ul> 
    28  * It is not possible to compare two task nodes conceptually. But the other design levels can be 
     28 * It is not possible to compare two tasks conceptually. But the other design levels can be 
    2929 * identified and compared. 
    3030 * </p> 
    3131 * <p> 
    32  * Nodes can be identical. This is the case if in the java virtual machine, their comparison 
     32 * Tasks can be identical. This is the case if in the java virtual machine, their comparison 
    3333 * using the <code>==</code> operator or the equals method return true. 
    3434 * </p> 
    3535 * <p> 
    36  * Nodes are lexically equal, if they represent the same events on a key stroke level to be 
    37  * carried out to execute the task. Identical nodes are also syntactically equal. 
     36 * Tasks are lexically equal, if they represent the same events on a key stroke level to be 
     37 * carried out to execute the task. Identical tasks are also syntactically equal. 
    3838 * </p> 
    3939 * <p> 
    … …  
    4141 * syntactical result is the same. For example, entering the text "hello" into a text field can 
    4242 * be done by entering the letters in their correct order, but also by copying the text into the 
    43  * text field. The syntactical result is the same: The text hello was entered. But the tasks 
     43 * text field. The syntactical result is the same: The text "hello" was entered. But the tasks 
    4444 * lexically differ because the events on key stroke level are different. On the other hand, 
    45  * lexically equal nodes are also syntactically equal.   
     45 * lexically equal tasks are also syntactically equal.   
    4646 * </p> 
    4747 * <p> 
    48  * Task tree nodes are semantically equal, if they execute the same function for editing the 
    49  * concepts. An example are a click on a button and a short cut, both executing the same function. 
    50  * These task tree nodes are syntactically and, therefore, also lexically different, but 
    51  * semantically equal. Syntactically equal task tree nodes are always also semantically equal. 
     48 * Tasks are semantically equal, if they execute the same function for editing the concepts. An 
     49 * example are a click on a button and a short cut, both executing the same function. These tasks 
     50 * are syntactically and, therefore, also lexically different, but semantically equal. 
     51 * Syntactically equal tasks are always also semantically equal. 
    5252 * </p> 
    5353 *  
    … …  
    5555 * @author 2012, last modified by $Author: patrick$ 
    5656 */ 
    57 public enum NodeEquality { 
     57public enum TaskEquality { 
    5858    IDENTICAL, 
    5959    LEXICALLY_EQUAL, 
    … …  
    6464    /** 
    6565     * <p> 
    66      * Checks for the current node equality, if it is at least identical to the 
    67      * provided one or even more concrete. As an example, the node equality identical also 
    68      * indicates, that the nodes are e.g. lexically, syntactically and semantically equal. 
     66     * Checks for the current task equality, if it is at least identical to the 
     67     * provided one or even more concrete. As an example, the task equality identical also 
     68     * indicates, that the tasks are e.g. lexically, syntactically and semantically equal. 
    6969     * Therefore, the method called on <code>IDENTICAL</code> with <code>SEMANTICALLY_EQUAL</code> 
    7070     * as parameter will return true. If this method is called on <code>SYNTACTICALLY_EQUAL</code> 
    … …  
    7272     * </p> 
    7373     * 
    74      * @param nodeEquality the node equality to compare with. 
     74     * @param taskEquality the task equality to compare with. 
    7575     *  
    7676     * @return as described 
    7777     */ 
    78     public boolean isAtLeast(NodeEquality nodeEquality) 
     78    public boolean isAtLeast(TaskEquality taskEquality) 
    7979    { 
    80         switch (nodeEquality) { 
     80        switch (taskEquality) { 
    8181            case IDENTICAL: 
    8282                return 
    … …  
    107107    /** 
    108108     * <p> 
    109      * returns the common denominator of this node equality and the provided one. I.e. if one 
     109     * returns the common denominator of this task equality and the provided one. I.e. if one 
    110110     * equality is e.g. syntactical and the other one only semantical, then semantical is returned. 
    111111     * </p> 
    112112     * 
    113113     * @param equality the equality, to compare this with 
    114      * @return 
     114     *  
     115     * @return as described 
    115116     */ 
    116     public NodeEquality getCommonDenominator(NodeEquality otherEquality) { 
     117    public TaskEquality getCommonDenominator(TaskEquality otherEquality) { 
    117118        if (this.isAtLeast(otherEquality)) { 
    118119            return otherEquality; 
    … …  
    122123        } 
    123124        else { 
    124             return NodeEquality.UNEQUAL; 
     125            return TaskEquality.UNEQUAL; 
    125126        } 
    126127    } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskEqualityRuleManager.java

    r1125 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1616 
    1717import java.util.ArrayList; 
    1818import java.util.List; 
    1919 
    20 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     20import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2121 
    2222/** 
    2323 * <p> 
    24  * The node equality rule manager is capable of comparing task tree nodes based on its internal list 
    25  * of comparison rules. The current list of rules contains the {@link NodeIdentityRule}, the 
     24 * The task equality rule manager is capable of comparing tasks based on its internal list 
     25 * of comparison rules. The current list of rules contains the {@link TaskIdentityRule}, the 
    2626 * {@link IterationComparisonRule}, the {@link SequenceComparisonRule}, and 
    27  * {@link SelectionComparisonRule}. These rules are asked for comparing the two provided task tree 
    28  * nodes in the mentioned order. If a rule returns a node equality other than null, this equality is 
     27 * {@link SelectionComparisonRule}. These rules are asked for comparing the two provided tasks 
     28 * in the mentioned order. If a rule returns a task equality other than null, this equality is 
    2929 * returned. Otherwise the next rule is asked. 
    3030 * </p> 
    … …  
    3333 * @author 2012, last modified by $Author: patrick$ 
    3434 */ 
    35 public class NodeEqualityRuleManager { 
     35public class TaskEqualityRuleManager { 
    3636 
    3737    /** */ 
    38     private List<NodeComparisonRule> mRuleIndex = null; 
    39  
    40     /** 
    41      * <p> 
    42      * initializes the node equality rule manager by filling the internal list of comparison rules. 
     38    private List<TaskComparisonRule> mRuleIndex = null; 
     39 
     40    /** 
     41     * <p> 
     42     * initializes the task equality rule manager by filling the internal list of comparison rules. 
    4343     * This method must be called before any other method is called on the rule manager. 
    4444     * </p> 
    4545     */ 
    4646    public void init() { 
    47         mRuleIndex = new ArrayList<NodeComparisonRule>(); 
    48         mRuleIndex.add(new NodeIdentityRule()); 
     47        mRuleIndex = new ArrayList<TaskComparisonRule>(); 
     48        mRuleIndex.add(new TaskIdentityRule()); 
    4949        mRuleIndex.add(new GUIEventTaskComparisonRule()); 
    5050        mRuleIndex.add(new EventTaskComparisonRule()); 
    … …  
    5252        mRuleIndex.add(new SequenceComparisonRule(this)); 
    5353        mRuleIndex.add(new SelectionComparisonRule(this)); 
    54         mRuleIndex.add(new NodeAndIterationComparisonRule(this)); 
    55         mRuleIndex.add(new NodeAndSelectionComparisonRule(this)); 
    56     } 
    57  
    58     /** 
    59      * <p> 
    60      * this method performs a comparison of the two provided task tree nodes. It iterates its 
    61      * internal comparison rules. If the first rule returns a node equality other than null, 
     54        mRuleIndex.add(new TaskAndIterationComparisonRule(this)); 
     55        mRuleIndex.add(new TaskAndSelectionComparisonRule(this)); 
     56    } 
     57 
     58    /** 
     59     * <p> 
     60     * this method performs a comparison of the two provided tasks. It iterates its internal 
     61     * comparison rules. If the first rule returns a task equality other than null, 
    6262     * this equality is returned. Otherwise the next rule is tried. If no rule returns an equality 
    6363     * <code>NodeEquality.UNEQUAL</code> is returned. 
    6464     * </p> 
    6565     *  
    66      * @param node1 the first task tree node to be compared 
    67      * @param node2 the second task tree node to be compared 
     66     * @param task1 the first task to be compared 
     67     * @param task2 the second task to be compared 
    6868     *  
    6969     * @return as described 
    … …  
    7272     *                               manager before a call to this method. 
    7373     */ 
    74     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) 
     74    public TaskEquality compare(ITask task1, ITask task2) 
    7575        throws IllegalStateException 
    7676    { 
    … …  
    7979        } 
    8080         
    81         // LOG.info("checking for equality of " + node1 + " and " + node2); 
    82         NodeEquality nodeEquality = null; 
    83  
    84         for (NodeComparisonRule rule : mRuleIndex) { 
    85             if (rule.isApplicable(node1, node2)) { 
    86                 nodeEquality = rule.compare(node1, node2); 
    87                 if (nodeEquality != null) { 
     81        // LOG.info("checking for equality of " + task1 + " and " + task2); 
     82        TaskEquality taskEquality = null; 
     83 
     84        for (TaskComparisonRule rule : mRuleIndex) { 
     85            if (rule.isApplicable(task1, task2)) { 
     86                taskEquality = rule.compare(task1, task2); 
     87                if (taskEquality != null) { 
    8888                    // LOG.warning("used rule " + rule + " for equality check"); 
    89                     return nodeEquality; 
     89                    return taskEquality; 
    9090                } 
    9191            } 
    9292        } 
    9393 
    94         // LOG.warning("no rule could be applied --> handling nodes as unequal"); 
    95  
    96         return NodeEquality.UNEQUAL; 
     94        // LOG.warning("no rule could be applied --> handling tasks as unequal"); 
     95 
     96        return TaskEquality.UNEQUAL; 
    9797    } 
    9898 
    … …  
    107107     * @return 
    108108     */ 
    109     public boolean areAtLeastEqual(ITaskTreeNode node1, 
    110                                    ITaskTreeNode node2, 
    111                                    NodeEquality  equalityLevel) 
    112     { 
     109    public boolean areAtLeastEqual(ITask task1, ITask task2, TaskEquality equalityLevel) { 
    113110        if (equalityLevel == null) { 
    114111            throw new IllegalArgumentException("required equality level must not be null"); 
    … …  
    117114        switch (equalityLevel) { 
    118115            case IDENTICAL: 
    119                 return areIdentical(node1, node2); 
     116                return areIdentical(task1, task2); 
    120117            case LEXICALLY_EQUAL: 
    121                 return areLexicallyEqual(node1, node2); 
     118                return areLexicallyEqual(task1, task2); 
    122119            case SYNTACTICALLY_EQUAL: 
    123                 return areSyntacticallyEqual(node1, node2); 
     120                return areSyntacticallyEqual(task1, task2); 
    124121            case SEMANTICALLY_EQUAL: 
    125                 return areSemanticallyEqual(node1, node2); 
     122                return areSemanticallyEqual(task1, task2); 
    126123            case UNEQUAL: 
    127                 return !areSemanticallyEqual(node1, node2); 
     124                return !areSemanticallyEqual(task1, task2); 
    128125            default: 
    129126                throw new IllegalArgumentException("unknown required equality: " + equalityLevel); 
    … …  
    140137     * @return 
    141138     */ 
    142     public boolean areIdentical(ITaskTreeNode node1, ITaskTreeNode node2) { 
    143         if (mRuleIndex == null) { 
    144             throw new IllegalStateException("not initialized"); 
    145         } 
    146          
    147         for (NodeComparisonRule rule : mRuleIndex) { 
    148             if (rule.isApplicable(node1, node2) && rule.areLexicallyEqual(node1, node2)) { 
    149                  return true; 
    150             } 
    151         } 
    152  
    153         return false; 
    154     } 
    155  
    156     /** 
    157      * <p> 
    158      * TODO: comment 
    159      * </p> 
    160      * 
    161      * @param child1 
    162      * @param child2 
    163      * @return 
    164      */ 
    165     public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    166         if (mRuleIndex == null) { 
    167             throw new IllegalStateException("not initialized"); 
    168         } 
    169          
    170         for (NodeComparisonRule rule : mRuleIndex) { 
    171             if (rule.isApplicable(node1, node2) && rule.areLexicallyEqual(node1, node2)) { 
    172                  return true; 
    173             } 
    174         } 
    175  
    176         return false; 
    177     } 
    178  
    179     /** 
    180      * <p> 
    181      * TODO: comment 
    182      * </p> 
    183      * 
    184      * @param child1 
    185      * @param child2 
    186      * @return 
    187      */ 
    188     public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    189         if (mRuleIndex == null) { 
    190             throw new IllegalStateException("not initialized"); 
    191         } 
    192          
    193         for (NodeComparisonRule rule : mRuleIndex) { 
    194             if (rule.isApplicable(node1, node2) && rule.areSyntacticallyEqual(node1, node2)) { 
    195                  return true; 
    196             } 
    197         } 
    198  
    199         return false; 
    200     } 
    201  
    202     /** 
    203      * <p> 
    204      * TODO: comment 
    205      * </p> 
    206      * 
    207      * @param child1 
    208      * @param child2 
    209      * @return 
    210      */ 
    211     public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    212         if (mRuleIndex == null) { 
    213             throw new IllegalStateException("not initialized"); 
    214         } 
    215          
    216         for (NodeComparisonRule rule : mRuleIndex) { 
    217             if (rule.isApplicable(node1, node2) && rule.areSemanticallyEqual(node1, node2)) { 
     139    public boolean areIdentical(ITask task1, ITask task2) { 
     140        if (mRuleIndex == null) { 
     141            throw new IllegalStateException("not initialized"); 
     142        } 
     143         
     144        for (TaskComparisonRule rule : mRuleIndex) { 
     145            if (rule.isApplicable(task1, task2) && rule.areLexicallyEqual(task1, task2)) { 
     146                 return true; 
     147            } 
     148        } 
     149 
     150        return false; 
     151    } 
     152 
     153    /** 
     154     * <p> 
     155     * TODO: comment 
     156     * </p> 
     157     * 
     158     * @param child1 
     159     * @param child2 
     160     * @return 
     161     */ 
     162    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     163        if (mRuleIndex == null) { 
     164            throw new IllegalStateException("not initialized"); 
     165        } 
     166         
     167        for (TaskComparisonRule rule : mRuleIndex) { 
     168            if (rule.isApplicable(task1, task2) && rule.areLexicallyEqual(task1, task2)) { 
     169                 return true; 
     170            } 
     171        } 
     172 
     173        return false; 
     174    } 
     175 
     176    /** 
     177     * <p> 
     178     * TODO: comment 
     179     * </p> 
     180     * 
     181     * @param child1 
     182     * @param child2 
     183     * @return 
     184     */ 
     185    public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     186        if (mRuleIndex == null) { 
     187            throw new IllegalStateException("not initialized"); 
     188        } 
     189         
     190        for (TaskComparisonRule rule : mRuleIndex) { 
     191            if (rule.isApplicable(task1, task2) && rule.areSyntacticallyEqual(task1, task2)) { 
     192                 return true; 
     193            } 
     194        } 
     195 
     196        return false; 
     197    } 
     198 
     199    /** 
     200     * <p> 
     201     * TODO: comment 
     202     * </p> 
     203     * 
     204     * @param child1 
     205     * @param child2 
     206     * @return 
     207     */ 
     208    public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     209        if (mRuleIndex == null) { 
     210            throw new IllegalStateException("not initialized"); 
     211        } 
     212         
     213        for (TaskComparisonRule rule : mRuleIndex) { 
     214            if (rule.isApplicable(task1, task2) && rule.areSemanticallyEqual(task1, task2)) { 
    218215                 return true; 
    219216            } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskIdentityRule.java

    r1125 r1146  
    1313//   limitations under the License. 
    1414 
    15 package de.ugoe.cs.autoquest.tasktrees.nodeequality; 
     15package de.ugoe.cs.autoquest.tasktrees.taskequality; 
    1616 
    17 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     17import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    1818 
    1919/** 
    2020 * <p> 
    21  * This comparison rule returns <code>NodeEquality.IDENTICAL</code> if the comparison of the two 
    22  * task tree nodes using the <code>==</code> operator or the <code>equals</code> method return true. 
    23  * Else it returns null to denote, that it can not compare the nodes. 
     21 * This comparison rule returns <code>TaskEquality.IDENTICAL</code> if the comparison of the two 
     22 * tasks using the <code>==</code> operator or the <code>equals</code> method return true. 
     23 * Else it returns null to denote, that it can not compare the tasks. 
    2424 * </p> 
    2525 *  
    … …  
    2727 * @author 2012, last modified by $Author: patrick$ 
    2828 */ 
    29 public class NodeIdentityRule implements NodeComparisonRule { 
     29public class TaskIdentityRule implements TaskComparisonRule { 
    3030 
    3131    /* (non-Javadoc) 
    32      * @see NodeComparisonRule#isApplicable(ITaskTreeNode, ITaskTreeNode) 
     32     * @see NodeComparisonRule#isApplicable(ITask, ITask) 
    3333     */ 
    3434    @Override 
    35     public boolean isApplicable(ITaskTreeNode node1, ITaskTreeNode node2) { 
    36         return (node1 == node2); 
     35    public boolean isApplicable(ITask task1, ITask task2) { 
     36        return (task1 == task2); 
    3737    } 
    3838 
    3939    /* (non-Javadoc) 
    40      * @see NodeComparisonRule#areLexicallyEqual(ITaskTreeNode, ITaskTreeNode) 
     40     * @see NodeComparisonRule#areLexicallyEqual(ITask, ITask) 
    4141     */ 
    4242    @Override 
    43     public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    44         return (node1 == node2); 
     43    public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     44        return (task1 == task2); 
    4545    } 
    4646 
    4747    /* (non-Javadoc) 
    48      * @see NodeComparisonRule#areSyntacticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     48     * @see NodeComparisonRule#areSyntacticallyEqual(ITask, ITask) 
    4949     */ 
    5050    @Override 
    51     public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    52         return (node1 == node2); 
     51    public boolean areSyntacticallyEqual(ITask task1, ITask task2) { 
     52        return (task1 == task2); 
    5353    } 
    5454 
    5555    /* (non-Javadoc) 
    56      * @see NodeComparisonRule#areSemanticallyEqual(ITaskTreeNode, ITaskTreeNode) 
     56     * @see NodeComparisonRule#areSemanticallyEqual(ITask, ITask) 
    5757     */ 
    5858    @Override 
    59     public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) { 
    60         return (node1 == node2); 
     59    public boolean areSemanticallyEqual(ITask task1, ITask task2) { 
     60        return (task1 == task2); 
    6161    } 
    6262 
    6363    /* (non-Javadoc) 
    64      * @see NodeComparisonRule#compare(ITaskTreeNode, ITaskTreeNode) 
     64     * @see NodeComparisonRule#compare(ITask, ITask) 
    6565     */ 
    6666    @Override 
    67     public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) { 
    68         if (isApplicable(node1, node2)) { 
    69             return NodeEquality.IDENTICAL; 
     67    public TaskEquality compare(ITask task1, ITask task2) { 
     68        if (isApplicable(task1, task2)) { 
     69            return TaskEquality.IDENTICAL; 
    7070        } 
    7171        else { 

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

    r1113 r1146  
    1515package de.ugoe.cs.autoquest.tasktrees.temporalrelation; 
    1616 
    17 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     17import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList; 
    1818 
    1919/** 
    2020 * <p> 
    21  * a temporal relationship rule is able to detected temporal relationships between the child nodes 
    22  * of the parent node provided to the {@link #apply(ITaskTreeNode, boolean)} method. A rule 
    23  * creates temporal relationships between the child nodes, i.e. substructures in the task tree, if 
    24  * it detects a temporal relationship and it can be sure that it is complete. Incomplete but 
    25  * detected temporal relationships may occur, if there can be more children expected to be added 
    26  * to the provided parent node. This could be the case during parsing a interaction log file of 
    27  * a GUI. 
     21 * a task instance list scope rule is able to detected temporal relationships between a list of task 
     22 * instances provided to the {@link #apply(ITaskInstanceList)} method. A rule creates temporal 
     23 * relationships between the task instances, i.e. substructures in the task tree, if 
     24 * it detects a temporal relationship and instantiates the temporal relationships accordingly. 
    2825 * </p> 
    2926 *  
    3027 * @author Patrick Harms 
    3128 */ 
    32 interface TemporalRelationshipRule { 
     29interface ITaskInstanceListScopeRule extends ITemporalRelationshipRule { 
    3330 
    3431  /** 
    3532   * <p> 
    36    * applies the rule to the given parent node. The finalize parameter is used to command the rule 
    37    * to finish rule applications, in the case it is known that no further data will be available.  
    38    * </p> 
    39    * <p> 
    40    * The returned rule application result is null, if the rule can not be applied, i.e. it does not 
    41    * detect a temporal relationship. It returns a rule application result with a status 
    42    * {@link RuleApplicationStatus#RULE_APPLICATION_FINISHED} if the rule was applied. The result 
    43    * contains all newly created parent nodes. It returns a rule application result with status 
    44    * {@link RuleApplicationStatus#RULE_APPLICATION_FEASIBLE} if the rule would be applicable if 
    45    * further children would be available in the parent node. This status MUST not be returned if  
    46    * the finalize parameter is true. In this case the rule must be applied or not.  
     33   * applies the rule to the given task instance list. The returned rule application result is null, 
     34   * if the rule can not be applied, i.e. it does not detect a temporal relationship. It returns a 
     35   * rule application result with a status {@link RuleApplicationStatus#RULE_APPLICATION_FINISHED} 
     36   * if the rule was applied. The result contains all newly created parent tasks and task instances. 
    4737   * </p> 
    4838   *  
    49    * @param parent   the parent node with the children to apply the rule on 
    50    * @param finalize true, if the rule shall not expect further children to come and that it 
    51    *                 should therefore be applied in any case 
     39   * @param taskInstances the list of task instances to apply the rule on 
    5240   *                     
    5341   * @return the rule application result as described. 
    5442   */ 
    55   RuleApplicationResult apply(ITaskTreeNode parent, 
    56                               boolean       finalize); 
     43  RuleApplicationResult apply(ITaskInstanceList taskInstances); 
    5744   
    5845} 

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

    r1127 r1146  
    1818import java.util.List; 
    1919 
    20 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     20import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
     21import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
    2122 
    2223/** 
    2324 * <p> 
    24  * The rule application result describes the result of applying a {@link TemporalRelationshipRule} 
    25  * on a task tree node. It contains a {@link RuleApplicationStatus} and a list of all parent 
    26  * task tree nodes that were created during a rule application. See the description of 
    27  * {@link TemporalRelationshipRule} for more details. 
     25 * The rule application result describes the result of applying a {@link ITemporalRelationshipRule}. 
     26 * It contains a {@link RuleApplicationStatus} and a list of all parent task instances and tasks 
     27 * that were created during a rule application. See the description of 
     28 * {@link ITemporalRelationshipRule} for more details. 
    2829 * </p> 
    2930 *  
    … …  
    3637 
    3738    /** */ 
    38     private List<ITaskTreeNode> newParents = new ArrayList<ITaskTreeNode>(); 
     39    private List<ITask> newParentTasks = new ArrayList<ITask>(); 
     40 
     41    /** */ 
     42    private List<ITaskInstance> newParentInstances = new ArrayList<ITaskInstance>(); 
    3943 
    4044    /** 
    … …  
    6771    /** 
    6872     * <p> 
    69      * add a further parent node created during the rule application 
     73     * add a further parent task created during the rule application 
    7074     * </p> 
    7175     */ 
    72     void addNewlyCreatedParentNode(ITaskTreeNode newParent) { 
    73         newParents.add(newParent); 
     76    void addNewlyCreatedTask(ITask newParent) { 
     77        newParentTasks.add(newParent); 
    7478    } 
    7579 
    7680    /** 
    7781     * <p> 
    78      * return all parent nodes created during the rule application 
     82     * return all parent tasks created during the rule application 
    7983     * </p> 
    8084     */ 
    81     List<ITaskTreeNode> getNewlyCreatedParentNodes() { 
    82         return newParents; 
     85    List<ITask> getNewlyCreatedTasks() { 
     86        return newParentTasks; 
     87    } 
     88 
     89    /** 
     90     * <p> 
     91     * add a further parent task instance created during the rule application 
     92     * </p> 
     93     */ 
     94    void addNewlyCreatedTaskInstance(ITaskInstance newParent) { 
     95        newParentInstances.add(newParent); 
     96    } 
     97 
     98    /** 
     99     * <p> 
     100     * return all parent task instances created during the rule application 
     101     * </p> 
     102     */ 
     103    List<ITaskInstance> getNewlyCreatedTaskInstances() { 
     104        return newParentInstances; 
    83105    } 
    84106 

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

    r1127 r1146  
    1717/** 
    1818 * <p> 
    19  * The rule application status describes the result of applying a {@link TemporalRelationshipRule} 
    20  * on a task tree node. See the description of {@link TemporalRelationshipRule} for more details. 
     19 * The rule application status describes the result of applying a {@link ITemporalRelationshipRule}. 
     20 * See the description of {@link ITemporalRelationshipRule} for more details. 
    2121 * </p> 
    2222 *  
    … …  
    2525enum RuleApplicationStatus { 
    2626    FINISHED, 
     27    // TODO drop feasible 
    2728    FEASIBLE, 
    2829    NOT_APPLIED; 

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

    r1127 r1146  
    1515package de.ugoe.cs.autoquest.tasktrees.temporalrelation; 
    1616 
    17 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    18 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; 
    19 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
    20 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; 
     17import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
     18import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; 
     19import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
     20import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList; 
     21import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
    2122 
    2223/** 
    … …  
    3536     *  
    3637     */ 
    37     static ISequence getSubSequenceInRange(ITaskTreeNode        parent, 
    38                                            int                   startIndex, 
    39                                            int                   endIndex, 
    40                                            String                description, 
    41                                            ITaskTreeNodeFactory  nodeFactory, 
    42                                            ITaskTreeBuilder      builder) 
     38    static ITaskInstance getSubSequenceInRange(ITaskInstanceList parent, 
     39                                               int               startIndex, 
     40                                               int               endIndex, 
     41                                               ITask             model, 
     42                                               ITaskFactory      taskFactory, 
     43                                               ITaskBuilder      taskBuilder) 
    4344    { 
    44         ISequence sequence = nodeFactory.createNewSequence(); 
    45         if (description != null) { 
    46             builder.setDescription(sequence, description); 
     45        ITaskInstance subsequence = taskFactory.createNewTaskInstance(model); 
     46 
     47        for (int i = startIndex; i <= endIndex; i++) { 
     48            taskBuilder.addChild(subsequence, parent.get(i)); 
    4749        } 
    4850 
    49         for (int i = startIndex; i <= endIndex; i++) { 
    50             builder.addChild(sequence, parent.getChildren().get(i)); 
    51         } 
    52  
    53         return sequence; 
     51        return subsequence; 
    5452    } 
    5553 
    … …  
    5755     *  
    5856     */ 
    59     static ISequence createNewSubSequenceInRange(ITaskTreeNode        parent, 
    60                                                  int                   startIndex, 
    61                                                  int                   endIndex, 
    62                                                  String                description, 
    63                                                  ITaskTreeNodeFactory  nodeFactory, 
    64                                                  ITaskTreeBuilder      builder) 
     57    static ITaskInstance createNewSubSequenceInRange(ITaskInstanceList parent, 
     58                                                     int               startIndex, 
     59                                                     int               endIndex, 
     60                                                     ITask             model, 
     61                                                     ITaskFactory      taskFactory, 
     62                                                     ITaskBuilder      taskBuilder) 
    6563    { 
    66         ISequence sequence = nodeFactory.createNewSequence(); 
    67         if (description != null) { 
    68             builder.setDescription(sequence, description); 
     64        ITaskInstance subsequence = taskFactory.createNewTaskInstance(model); 
     65 
     66        for (int i = startIndex; i <= endIndex; i++) { 
     67            taskBuilder.addChild(subsequence, parent.get(startIndex)); 
     68            taskBuilder.removeTaskInstance(parent, startIndex); 
    6969        } 
    7070 
    71         for (int i = startIndex; i <= endIndex; i++) { 
    72             builder.addChild(sequence, parent.getChildren().get(startIndex)); 
    73             builder.removeChild((ISequence) parent, startIndex); 
    74         } 
    7571 
    76         builder.addChild((ISequence) parent, startIndex, sequence); 
     72        taskBuilder.addTaskInstance(parent, startIndex, subsequence); 
    7773 
    78         return sequence; 
     74        return subsequence; 
    7975    } 
    8076 

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

    r1133 r1146  
    1515package de.ugoe.cs.autoquest.tasktrees.temporalrelation; 
    1616 
     17import java.util.HashMap; 
    1718import java.util.Iterator; 
    1819import java.util.LinkedList; 
    1920import java.util.List; 
    2021 
    21 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; 
    22 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager; 
     22import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; 
     23import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; 
     24import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; 
    2325import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration; 
    2426import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; 
    2527import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    26 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; 
    27 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
    28 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; 
     28import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
     29import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; 
     30import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
     31import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
     32import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList; 
     33import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession; 
     34import de.ugoe.cs.autoquest.usageprofiles.SymbolComparator; 
    2935import de.ugoe.cs.autoquest.usageprofiles.Trie; 
    3036import de.ugoe.cs.autoquest.usageprofiles.TrieProcessor; 
    3137import de.ugoe.cs.util.StopWatch; 
    32 import de.ugoe.cs.util.console.Console; 
    3338 
    3439/** 
    … …  
    3944 * @author Patrick Harms 
    4045 */ 
    41 class SequenceForTaskDetectionRule implements TemporalRelationshipRule { 
     46class SequenceForTaskDetectionRule implements ISessionScopeRule { 
    4247     
    4348    /** 
    4449     * <p> 
    45      * the task tree node factory to be used for creating substructures for the temporal 
     50     * the task factory to be used for creating substructures for the temporal 
    4651     * relationships identified during rule 
    4752     * </p> 
    4853     */ 
    49     private ITaskTreeNodeFactory taskTreeNodeFactory; 
     54    private ITaskFactory taskFactory; 
    5055    /** 
    5156     * <p> 
    52      * the task tree builder to be used for creating substructures for the temporal relationships 
     57     * the task builder to be used for creating substructures for the temporal relationships 
    5358     * identified during rule application 
    5459     * </p> 
    5560     */ 
    56     private ITaskTreeBuilder taskTreeBuilder; 
     61    private ITaskBuilder taskBuilder; 
    5762 
    5863    /** 
    5964     * <p> 
    60      * the node comparator to be used for comparing task tree nodes 
     65     * the task comparator to be used for comparing tasks 
    6166     * </p> 
    6267     */ 
    63     private TaskTreeNodeComparator nodeComparator; 
     68    private TaskComparator taskComparator; 
    6469 
    6570    /** 
    6671     * <p> 
    67      * instantiates the rule and initializes it with a node equality rule manager and the minimal 
    68      * node equality identified sublist must have to consider them as iterated. 
     72     * instantiates the rule and initializes it with a task equality rule manager and the minimal 
     73     * task equality identified sublist must have to consider them as iterated. 
    6974     * </p> 
    7075     */ 
    71     SequenceForTaskDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager, 
    72                                  NodeEquality            minimalNodeEquality, 
    73                                  ITaskTreeNodeFactory    taskTreeNodeFactory, 
    74                                  ITaskTreeBuilder        taskTreeBuilder) 
     76    SequenceForTaskDetectionRule(TaskEqualityRuleManager taskEqualityRuleManager, 
     77                                 TaskEquality            minimalTaskEquality, 
     78                                 ITaskFactory            taskFactory, 
     79                                 ITaskBuilder            taskBuilder) 
    7580    { 
    76         this.taskTreeNodeFactory = taskTreeNodeFactory; 
    77         this.taskTreeBuilder = taskTreeBuilder; 
    78          
    79         this.nodeComparator = 
    80             new TaskTreeNodeComparator(nodeEqualityRuleManager, minimalNodeEquality); 
     81        this.taskFactory = taskFactory; 
     82        this.taskBuilder = taskBuilder; 
     83         
     84        this.taskComparator = new TaskComparator(taskEqualityRuleManager, minimalTaskEquality); 
    8185    } 
    8286 
    … …  
    8993    } 
    9094 
    91     /* 
    92      * (non-Javadoc) 
    93      *  
    94      * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, 
    95      * boolean) 
     95    /* (non-Javadoc) 
     96     * @see de.ugoe.cs.autoquest.tasktrees.temporalrelation.ISessionScopeRule#apply(java.util.List) 
    9697     */ 
    9798    @Override 
    98     public RuleApplicationResult apply(ITaskTreeNode parent, boolean finalize) { 
    99         if (!(parent instanceof ISequence)) { 
    100             return null; 
    101         } 
    102  
    103         if (!finalize) { 
    104             // the rule is always feasible as tasks may occur at any time 
    105             RuleApplicationResult result = new RuleApplicationResult(); 
    106             result.setRuleApplicationStatus(RuleApplicationStatus.FEASIBLE); 
    107             return result; 
    108         } 
    109  
    110         List<ITaskTreeNode> children = parent.getChildren(); 
    111         List<ISequence> sessions = new LinkedList<ISequence>(); 
    112          
    113         for (ITaskTreeNode child : children) { 
    114             if (child instanceof ISequence) { 
    115                 sessions.add((ISequence) child); 
    116             } 
    117             else { 
    118                 Console.println("provided parent is no parent of sessions"); 
    119                 return null; 
    120             } 
    121         } 
    122          
     99    public RuleApplicationResult apply(List<IUserSession> sessions) { 
    123100        RuleApplicationData appData = new RuleApplicationData(sessions); 
    124101 
    125         boolean finished = false; 
    126          
    127102        // this is the real rule application. Loop while something is replaced. 
    128103        do { 
    … …  
    137112            appData.getStopWatch().stop("whole loop"); 
    138113             
    139             //((TaskTreeNodeComparator) nodeComparator).getStopWatch().dumpStatistics(System.out); 
    140             //((TaskTreeNodeComparator) nodeComparator).getStopWatch().reset(); 
     114            //((TaskTreeNodeComparator) taskComparator).getStopWatch().dumpStatistics(System.out); 
     115            //((TaskTreeNodeComparator) taskComparator).getStopWatch().reset(); 
    141116             
    142117            appData.getStopWatch().dumpStatistics(System.out); 
    143118            appData.getStopWatch().reset(); 
    144119             
    145             finished = (appData.getReplacementCounter() == 0); 
    146         } 
    147         while (!finished); 
    148          
    149         System.out.println("created " + appData.getResult().getNewlyCreatedParentNodes().size() + 
    150                            " new parent nodes\n"); 
    151          
    152         if (appData.getResult().getNewlyCreatedParentNodes().size() > 0) { 
     120        } 
     121        while (appData.detectedAndReplacedTasks()); 
     122         
     123        System.out.println 
     124            ("created " + appData.getResult().getNewlyCreatedTasks().size() + 
     125             " new tasks and " + appData.getResult().getNewlyCreatedTaskInstances().size() + 
     126             " appropriate instances\n"); 
     127         
     128        if ((appData.getResult().getNewlyCreatedTasks().size() > 0) || 
     129            (appData.getResult().getNewlyCreatedTaskInstances().size() > 0)) 
     130        { 
    153131            appData.getResult().setRuleApplicationStatus(RuleApplicationStatus.FINISHED); 
    154132        } 
    … …  
    164142        appData.getStopWatch().start("detecting iterations"); 
    165143         
    166         List<ISequence> sessions = appData.getSessions(); 
    167         int foundIterations = 0; 
    168          
    169         for (ISequence session : sessions) { 
    170             foundIterations += detectAndReplaceIterations(session, appData); 
    171         } 
     144        List<IUserSession> sessions = appData.getSessions(); 
     145        int iteratedTasks = 0; 
     146         
     147        ITask iteratedTask = null; 
     148         
     149        do { 
     150            iteratedTask = searchIteratedTask(sessions); 
     151             
     152            if (iteratedTask != null) { 
     153                replaceIterationsOf(iteratedTask, sessions, appData); 
     154                iteratedTasks++; 
     155            } 
     156        } 
     157        while (iteratedTask != null); 
    172158         
    173159        appData.getStopWatch().stop("detecting iterations"); 
    174         System.out.println(" --> found " + foundIterations); 
    175     } 
    176  
    177     /** 
    178      * @param appData 
    179      */ 
    180     private int detectAndReplaceIterations(ISequence           session, 
    181                                            RuleApplicationData appData) 
     160        System.out.println(" --> found " + iteratedTasks + " iterated tasks"); 
     161    } 
     162 
     163    /** 
     164     * 
     165     */ 
     166    private ITask searchIteratedTask(List<IUserSession> sessions) { 
     167        for (IUserSession session : sessions) { 
     168            for (int i = 0; i < (session.size() - 1); i++) { 
     169                if (taskComparator.equals(session.get(i).getTask(), session.get(i + 1).getTask())) { 
     170                    return session.get(i).getTask(); 
     171                } 
     172            } 
     173        } 
     174         
     175        return null; 
     176    } 
     177 
     178    /** 
     179     * 
     180     */ 
     181    private void replaceIterationsOf(ITask               iteratedTask, 
     182                                     List<IUserSession>  sessions, 
     183                                     RuleApplicationData appData) 
    182184    { 
    183         int count = 0; 
    184          
    185         TemporalRelationshipRule rule = new SimpleIterationDetectionRule 
    186             (nodeComparator, taskTreeNodeFactory, taskTreeBuilder); 
    187  
    188         RuleApplicationResult result = rule.apply(session, true); 
    189              
    190         if ((result != null) && (result.getNewlyCreatedParentNodes() != null)) { 
    191             for (ITaskTreeNode newParent : result.getNewlyCreatedParentNodes()) { 
    192                 appData.getResult().addNewlyCreatedParentNode(newParent); 
    193                 if (newParent instanceof IIteration) { 
    194                     count++; 
    195                 } 
    196             } 
    197         } 
    198          
    199         return count; 
     185        IIteration iteration = taskFactory.createNewIteration(); 
     186        ITaskInstance iterationInstance = null; 
     187         
     188        List<ITaskInstance> iterationInstances = new LinkedList<ITaskInstance>(); 
     189         
     190        for (IUserSession session : sessions) { 
     191            int index = 0; 
     192            while (index < session.size()) { 
     193                if (taskComparator.equals(iteratedTask, session.get(index).getTask())) { 
     194                    if (iterationInstance == null) { 
     195                        iterationInstance = taskFactory.createNewTaskInstance(iteration); 
     196                        iterationInstances.add(iterationInstance); 
     197                        taskBuilder.addTaskInstance(session, index, iterationInstance); 
     198                        index++; 
     199                    } 
     200                     
     201                    taskBuilder.addChild(iterationInstance, session.get(index)); 
     202                    taskBuilder.removeTaskInstance(session, index); 
     203                } 
     204                else { 
     205                    if (iterationInstance != null) { 
     206                        iterationInstance = null; 
     207                    } 
     208                    index++; 
     209                } 
     210            } 
     211        } 
     212         
     213        harmonizeIterationInstancesModel(iteration, iterationInstances); 
     214    } 
     215 
     216    /** 
     217     * <p> 
     218     * TODO: comment 
     219     * </p> 
     220     * 
     221     * @param iteratedTaskVariants 
     222     */ 
     223    private void harmonizeIterationInstancesModel(IIteration          iteration, 
     224                                                  List<ITaskInstance> iterationInstances) 
     225    { 
     226        List<ITask> iteratedTaskVariants = new LinkedList<ITask>(); 
     227         
     228        // merge the lexically different variants of iterated task to a unique list  
     229        for (ITaskInstance iterationInstance : iterationInstances) { 
     230            for (ITaskInstance executionVariant : iterationInstance) { 
     231                ITask candidate = executionVariant.getTask(); 
     232             
     233                boolean found = false; 
     234                for (ITask taskVariant : iteratedTaskVariants) { 
     235                    if (taskComparator.areLexicallyEqual(taskVariant, candidate)) { 
     236                        taskBuilder.setTask(executionVariant, taskVariant); 
     237                        found = true; 
     238                        break; 
     239                    } 
     240                } 
     241                 
     242                if (!found) { 
     243                    iteratedTaskVariants.add(candidate); 
     244                } 
     245            } 
     246        } 
     247         
     248        // if there are more than one lexically different variant of iterated tasks, adapt the 
     249        // iteration model to be a selection of different variants. In this case also adapt 
     250        // the generated iteration instances to correctly contain selection instances. If there 
     251        // is only one variant of an iterated task, simply set this as the marked task of the 
     252        // iteration. In this case, the instances can be preserved as is 
     253        if (iteratedTaskVariants.size() > 1) { 
     254            ISelection selection = taskFactory.createNewSelection(); 
     255             
     256            for (ITask variant : iteratedTaskVariants) { 
     257                taskBuilder.addChild(selection, variant); 
     258            } 
     259             
     260            taskBuilder.setMarkedTask(iteration, selection); 
     261             
     262            for (ITaskInstance instance : iterationInstances) { 
     263                for (int i = 0; i < instance.size(); i++) { 
     264                    ITaskInstance selectionInstance = taskFactory.createNewTaskInstance(selection); 
     265                    taskBuilder.addChild(selectionInstance, instance.get(i)); 
     266                    taskBuilder.setTaskInstance(instance, i, selectionInstance); 
     267                } 
     268            } 
     269        } 
     270        else { 
     271            taskBuilder.setMarkedTask(iteration, iteratedTaskVariants.get(0)); 
     272        } 
    200273    } 
    201274 
    … …  
    226299        Tasks tasks; 
    227300        boolean createNewTrie = (appData.getLastTrie() == null) || 
    228             appData.getReplacementCounter() > 0; // tree has changed 
     301            appData.detectedAndReplacedTasks(); // tree has changed 
    229302         
    230303        do { 
    … …  
    240313            createNewTrie = false; 
    241314             
    242             for (List<ITaskTreeNode> task : tasks) { 
     315            for (List<ITaskInstance> task : tasks) { 
    243316                if (task.size() >= appData.getTrainedSequenceLength()) { 
    244317                    // Trie must be recreated with a longer sequence length to be sure that 
    … …  
    267340 
    268341        appData.getStopWatch().start("training trie"); 
    269         appData.setLastTrie(new Trie<ITaskTreeNode>(nodeComparator)); 
     342        appData.setLastTrie(new Trie<ITaskInstance>(taskComparator)); 
    270343     
    271         List<ISequence> sessions = appData.getSessions(); 
    272          
    273         for (ISequence session : sessions) { 
     344        List<IUserSession> sessions = appData.getSessions(); 
     345         
     346        for (IUserSession session : sessions) { 
    274347            trainTrie(session, appData); 
    275348        } 
    … …  
    282355     * @param parent 
    283356     */ 
    284     private void trainTrie(ISequence session, RuleApplicationData appData) { 
    285         List<ITaskTreeNode> children = session.getChildren(); 
     357    private void trainTrie(IUserSession session, RuleApplicationData appData) { 
     358        List<ITaskInstance> children = session.getExecutedTasks(); 
    286359         
    287360        if ((children != null) && (children.size() > 0)) { 
    … …  
    294367     */ 
    295368    private void replaceSequencesOccurringMostOften(RuleApplicationData appData) { 
    296         appData.resetReplacementCounter(); 
     369        appData.detectedAndReplacedTasks(false); 
    297370 
    298371        if ((appData.getLastFoundTasks().size() > 0) && 
    299372            (appData.getLastFoundTasks().getOccurrenceCount() > 1)) 
    300373        { 
    301             System.out.println("replacing tasks occurrences with merged variants of all versions"); 
    302  
    303             for (List<ITaskTreeNode> task : appData.getLastFoundTasks()) { 
    304                 String taskId = "task " + RuleUtils.getNewId(); 
    305                 System.out.println("replacing " + taskId + ": " + task); 
    306  
    307                 appData.clearTaskOccurrences(); 
    308                 determineVariantsOfTaskOccurrences(task, appData.getSessions(), appData); 
    309                  
    310                 appData.getStopWatch().start("merging task nodes"); 
    311                 ITaskTreeNode taskReplacement = mergeVariantsOfTaskOccurrence(taskId, appData); 
    312                 appData.getStopWatch().stop("merging task nodes"); 
    313  
    314                 appData.resetReplacementCounter(); 
    315                 replaceTaskOccurrences(task, taskReplacement, appData.getSessions(), appData); 
    316  
    317                 if (appData.getReplacementCounter() > 0) { 
    318                     appData.getResult().addNewlyCreatedParentNode(taskReplacement); 
    319                 } 
    320  
    321                 if (appData.getReplacementCounter() < 
    322                     appData.getLastFoundTasks().getOccurrenceCount()) 
    323                 { 
    324                     System.out.println(taskId + ": replaced task only " + 
    325                                        appData.getReplacementCounter() + 
    326                                        " times instead of expected " + 
     374            System.out.println("replacing tasks occurrences"); 
     375 
     376            for (List<ITaskInstance> task : appData.getLastFoundTasks()) { 
     377                ISequence sequence = taskFactory.createNewSequence(); 
     378                 
     379                System.out.println("replacing " + sequence.getId() + ": " + task); 
     380 
     381                List<ITaskInstance> sequenceInstances = 
     382                    replaceTaskOccurrences(task, appData.getSessions(), sequence); 
     383                 
     384                harmonizeSequenceInstancesModel(sequence, sequenceInstances,task.size()); 
     385                appData.detectedAndReplacedTasks(sequenceInstances.size() > 0); 
     386 
     387                if (sequenceInstances.size() < appData.getLastFoundTasks().getOccurrenceCount()) { 
     388                    System.out.println(sequence.getId() + ": replaced task only " + 
     389                                       sequenceInstances.size() + " times instead of expected " + 
    327390                                       appData.getLastFoundTasks().getOccurrenceCount()); 
    328391                } 
    … …  
    333396 
    334397    /** 
    335      * @param tree 
    336      */ 
    337     private void determineVariantsOfTaskOccurrences(List<ITaskTreeNode> task, 
    338                                                     List<ISequence>     sessions, 
    339                                                     RuleApplicationData appData) 
     398     * 
     399     */ 
     400    private void harmonizeSequenceInstancesModel(ISequence           sequence, 
     401                                                 List<ITaskInstance> sequenceInstances, 
     402                                                 int                 sequenceLength) 
    340403    { 
    341         for (ISequence session : sessions) { 
    342             int index = -1; 
    343                  
    344             List<ITaskTreeNode> children = session.getChildren(); 
    345  
    346             do { 
    347                 index = getSubListIndex(children, task, ++index); 
    348  
    349                 if (index > -1) { 
    350                     ISequence taskOccurrence = RuleUtils.getSubSequenceInRange 
    351                             (session, index, index + task.size() - 1, null, 
    352                              taskTreeNodeFactory, taskTreeBuilder); 
    353  
    354                     appData.addTaskOccurrence(taskOccurrence); 
    355  
    356                     // let the index point to the last element the belongs the identified occurrence 
    357                     index += task.size() - 1; 
    358                 } 
    359             } 
    360             while (index > -1); 
    361         } 
    362     } 
    363  
    364     /** 
    365      * @param appData 
    366      * @return 
    367      */ 
    368     private ITaskTreeNode mergeVariantsOfTaskOccurrence(String              taskId, 
    369                                                         RuleApplicationData appData) 
    370     { 
    371         return mergeVariantsOfTasks(taskId, appData.getTaskOccurrences()); 
    372     } 
    373  
    374     /** 
    375      * @param appData 
    376      * @return 
    377      */ 
    378     private ITaskTreeNode mergeVariantsOfTasks(String description, List<ITaskTreeNode> variants) { 
    379         // merge but preserve lexically distinct variants 
    380         TaskTreeNodeMerger merger = new TaskTreeNodeMerger 
    381             (taskTreeNodeFactory, taskTreeBuilder, nodeComparator); 
    382          
    383         merger.mergeTaskNodes(variants); 
    384          
    385         if (variants.size() == 1) { 
    386             ITaskTreeNode replacement = variants.get(0); 
    387             taskTreeBuilder.setDescription(replacement, description); 
    388             return replacement; 
    389         } 
    390         else { 
    391             ISelection selection = taskTreeNodeFactory.createNewSelection(); 
    392             taskTreeBuilder.setDescription(selection, "variants of task " + description); 
    393              
    394             for (ITaskTreeNode variant : variants) { 
    395                 taskTreeBuilder.addChild(selection, variant); 
    396             } 
    397              
    398             return selection; 
    399         } 
    400     } 
    401  
    402     /** 
    403      * @param task 
    404      * @param parent 
    405      * @param treeBuilder 
    406      * @param nodeFactory 
    407      * @param result 
    408      */ 
    409     private void replaceTaskOccurrences(List<ITaskTreeNode> task, 
    410                                         ITaskTreeNode       replacement, 
    411                                         List<ISequence>     sessions, 
    412                                         RuleApplicationData appData) 
    413     { 
    414         // now check the children themselves for an occurrence of the task 
    415         for (int i = 0; i < sessions.size(); i++) { 
    416             ISequence session = sessions.get(i); 
    417              
    418             int index = -1; 
    419          
    420             List<ITaskTreeNode> children = session.getChildren(); 
    421  
    422             do { 
    423                 index = getSubListIndex(children, task, ++index); 
    424  
    425                 if (index > -1) { 
    426                     if ((!(replacement instanceof ISequence)) || 
    427                         (task.size() < children.size())) 
    428                     { 
    429                         for (int j = index; j < index + task.size(); j++) { 
    430                             taskTreeBuilder.removeChild(session, index); 
    431                         } 
    432  
    433                         taskTreeBuilder.addChild(session, index, replacement); 
    434                         appData.incrementReplacementCounter(); 
    435  
    436                         children = session.getChildren(); 
    437                     } 
    438                     else { 
    439                         // the whole list of children is an occurrence of this task. So ask the 
    440                         // caller of the method to replace the whole node 
    441                         sessions.set(i, (ISequence) replacement); 
    442                         appData.incrementReplacementCounter(); 
     404         
     405        // ensure for each subtask that lexically different variants are preserved 
     406        for (int subTaskIndex = 0; subTaskIndex < sequenceLength; subTaskIndex++) { 
     407            List<ITask> subTaskVariants = new LinkedList<ITask>(); 
     408             
     409            for (ITaskInstance sequenceInstance : sequenceInstances) { 
     410                ITask candidate = sequenceInstance.get(subTaskIndex).getTask(); 
     411                 
     412                boolean found = false; 
     413                 
     414                for (int i = 0; i < subTaskVariants.size(); i++) { 
     415                    if (taskComparator.areLexicallyEqual(subTaskVariants.get(i), candidate)) { 
     416                        taskBuilder.setTask 
     417                            (sequenceInstance.get(subTaskIndex), subTaskVariants.get(i)); 
     418                         
     419                        found = true; 
    443420                        break; 
    444421                    } 
    445422                } 
     423                 
     424                if (!found) { 
     425                    subTaskVariants.add(candidate); 
     426                } 
     427            } 
     428             
     429            // if there are more than one lexically different variant of the sub task at 
     430            // the considered position, adapt the sequence model at that position to have 
     431            // a selection of the different variants. In this case also adapt the 
     432            // generated sequence instances to correctly contain selection instances. If 
     433            // there is only one variant of sub tasks at the given position, simply set 
     434            // this variant as the sub task of the selection. In this case, the instances 
     435            // can be preserved as is 
     436            if (subTaskVariants.size() > 1) { 
     437                ISelection selection = taskFactory.createNewSelection(); 
     438                 
     439                for (ITask variant : subTaskVariants) { 
     440                    taskBuilder.addChild(selection, variant); 
     441                } 
     442                 
     443                taskBuilder.addChild(sequence, selection); 
     444                 
     445                for (ITaskInstance instance : sequenceInstances) { 
     446                    ITaskInstance selectionInstance = 
     447                        taskFactory.createNewTaskInstance(selection); 
     448                    taskBuilder.addChild(selectionInstance, instance.get(subTaskIndex)); 
     449                    taskBuilder.setTaskInstance(instance, subTaskIndex, selectionInstance); 
     450                } 
     451            } 
     452            else if (subTaskVariants.size() == 1) { 
     453                taskBuilder.addChild(sequence, subTaskVariants.get(0)); 
     454            } 
     455        } 
     456    } 
     457 
     458    /** 
     459     * @param tree 
     460     */ 
     461    private List<ITaskInstance> replaceTaskOccurrences(List<ITaskInstance> task, 
     462                                                       List<IUserSession>  sessions, 
     463                                                       ISequence           temporalTaskModel) 
     464    { 
     465        List<ITaskInstance> sequenceInstances = new LinkedList<ITaskInstance>(); 
     466         
     467        for (IUserSession session : sessions) { 
     468            int index = -1; 
     469                 
     470            do { 
     471                index = getSubListIndex(session, task, ++index); 
     472 
     473                if (index > -1) { 
     474                    sequenceInstances.add 
     475                        (RuleUtils.createNewSubSequenceInRange 
     476                             (session, index, index + task.size() - 1, temporalTaskModel, 
     477                              taskFactory, taskBuilder)); 
     478                } 
    446479            } 
    447480            while (index > -1); 
    448481        } 
     482         
     483        return sequenceInstances; 
    449484    } 
    450485 
    … …  
    454489     * @return 
    455490     */ 
    456     private int getSubListIndex(List<ITaskTreeNode> list, 
    457                                 List<ITaskTreeNode> subList, 
     491    private int getSubListIndex(ITaskInstanceList  list, 
     492                                List<ITaskInstance> subList, 
    458493                                int                 startIndex) 
    459494    { 
    … …  
    465500             
    466501            for (int j = 0; j < subList.size(); j++) { 
    467                 if (!nodeComparator.equals(list.get(i + j), subList.get(j))) { 
     502                if (!taskComparator.equals(list.get(i + j), subList.get(j))) { 
    468503                    matchFound = false; 
    469504                    break; 
    … …  
    479514        return result; 
    480515    } 
     516 
     517    /** 
     518     * @param trie 
     519     * @param object 
     520     * @return 
     521     */ 
     522    private int getSubListIndex(List<ITaskInstance> list, 
     523                                List<ITaskInstance> subList, 
     524                                int                 startIndex) 
     525    { 
     526        boolean matchFound; 
     527        int result = -1; 
     528         
     529        for (int i = startIndex; i <= list.size() - subList.size(); i++) { 
     530            matchFound = true; 
     531             
     532            for (int j = 0; j < subList.size(); j++) { 
     533                if (!taskComparator.equals(list.get(i + j), subList.get(j))) { 
     534                    matchFound = false; 
     535                    break; 
     536                } 
     537            } 
     538             
     539            if (matchFound) { 
     540                result = i; 
     541                break; 
     542            } 
     543        } 
     544         
     545        return result; 
     546    } 
    481547     
    482548    /** 
    483549     * @author Patrick Harms 
    484550     */ 
    485     private class MaxCountAndLongestTasksFinder implements TrieProcessor<ITaskTreeNode> { 
     551    private class MaxCountAndLongestTasksFinder implements TrieProcessor<ITaskInstance> { 
    486552         
    487553        /** 
    … …  
    493559         *  
    494560         */ 
    495         private List<List<ITaskTreeNode>> foundTasks = new LinkedList<List<ITaskTreeNode>>(); 
     561        private List<List<ITaskInstance>> foundTasks = new LinkedList<List<ITaskInstance>>(); 
    496562 
    497563        /** 
    … …  
    507573         */ 
    508574        @Override 
    509         public TrieProcessor.Result process(List<ITaskTreeNode> task, int count) { 
    510             if (task.size() < 2) { 
    511                 // ignore single nodes 
     575        public TrieProcessor.Result process(List<ITaskInstance> foundTask, int count) { 
     576            if (foundTask.size() < 2) { 
     577                // ignore single tasks 
    512578                return TrieProcessor.Result.CONTINUE; 
    513579            } 
    … …  
    519585 
    520586            if (this.currentCount > count) { 
    521                 // ignore this children of this node, as they may have only smaller counts than 
     587                // ignore this children of this task, as they may have only smaller counts than 
    522588                // the already found tasks 
    523589                return TrieProcessor.Result.SKIP_NODE; 
    … …  
    536602                boolean added = false; 
    537603                for (int i = 0; i < foundTasks.size(); i++) { 
    538                     if (foundTasks.get(i).size() < task.size()) { 
     604                    if (foundTasks.get(i).size() < foundTask.size()) { 
    539605                        // defensive copy 
    540                         foundTasks.add(i, new LinkedList<ITaskTreeNode>(task)); // defensive copy 
     606                        foundTasks.add(i, new LinkedList<ITaskInstance>(foundTask)); // defensive copy 
    541607                        added = true; 
    542608                        break; 
    … …  
    545611                 
    546612                if (!added) { 
    547                     foundTasks.add(new LinkedList<ITaskTreeNode>(task)); // defensive copy 
     613                    foundTasks.add(new LinkedList<ITaskInstance>(foundTask)); // defensive copy 
    548614                } 
    549615            } 
    … …  
    571637                        // found a task that is a potential subtask. Check for this and remove the 
    572638                        // subtask if needed 
    573                         List<ITaskTreeNode> longTask = foundTasks.get(i); 
    574                         List<ITaskTreeNode> shortTask = foundTasks.get(j); 
     639                        List<ITaskInstance> longTask = foundTasks.get(i); 
     640                        List<ITaskInstance> shortTask = foundTasks.get(j); 
    575641                         
    576642                        if (getSubListIndex(longTask, shortTask, 0) > -1) { 
    … …  
    598664         *  
    599665         */ 
    600         private List<ISequence> sessions; 
    601          
    602         /** 
    603          *  
    604          */ 
    605         private Trie<ITaskTreeNode> lastTrie; 
     666        private List<IUserSession> sessions; 
     667         
     668        /** 
     669         *  
     670         */ 
     671        private Trie<ITaskInstance> lastTrie; 
    606672         
    607673        /** 
    … …  
    618684         *  
    619685         */ 
    620         private List<ITaskTreeNode> taskOccurrences = new LinkedList<ITaskTreeNode>(); 
    621          
    622         /** 
    623          *  
    624          */ 
    625         private int replacementCounter; 
     686        private boolean detectedAndReplacedTasks; 
    626687         
    627688        /** 
    … …  
    638699         *  
    639700         */ 
    640         private RuleApplicationData(List<ISequence> sessions) { 
     701        private RuleApplicationData(List<IUserSession> sessions) { 
    641702            this.sessions = sessions; 
    642703        } 
    … …  
    645706         * @return the tree 
    646707         */ 
    647         private List<ISequence> getSessions() { 
     708        private List<IUserSession> getSessions() { 
    648709            return sessions; 
    649710        } 
    … …  
    652713         * @param lastTrie the lastTrie to set 
    653714         */ 
    654         private void setLastTrie(Trie<ITaskTreeNode> lastTrie) { 
     715        private void setLastTrie(Trie<ITaskInstance> lastTrie) { 
    655716            this.lastTrie = lastTrie; 
    656717        } 
    … …  
    659720         * @return the lastTrie 
    660721         */ 
    661         private Trie<ITaskTreeNode> getLastTrie() { 
     722        private Trie<ITaskInstance> getLastTrie() { 
    662723            return lastTrie; 
    663724        } 
    … …  
    692753 
    693754        /** 
    694          * @return the taskOccurrences 
    695          */ 
    696         private void clearTaskOccurrences() { 
    697             taskOccurrences.clear(); 
    698         } 
    699  
    700         /** 
    701          * @return the taskOccurrences 
    702          */ 
    703         private void addTaskOccurrence(ITaskTreeNode taskOccurrence) { 
    704             taskOccurrences.add(taskOccurrence); 
    705         } 
    706  
    707         /** 
    708          * @return the taskOccurrences 
    709          */ 
    710         private List<ITaskTreeNode> getTaskOccurrences() { 
    711             return taskOccurrences; 
    712         } 
    713  
    714         /** 
    715755         * 
    716756         */ 
    717         private void resetReplacementCounter() { 
    718             replacementCounter = 0; 
     757        private void detectedAndReplacedTasks(boolean detectedAndReplacedTasks) { 
     758            this.detectedAndReplacedTasks = detectedAndReplacedTasks; 
    719759        } 
    720760 
    … …  
    722762         * 
    723763         */ 
    724         private void incrementReplacementCounter() { 
    725             replacementCounter++; 
    726         } 
    727  
    728         /** 
    729          * 
    730          */ 
    731         private int getReplacementCounter() { 
    732             return replacementCounter; 
     764        private boolean detectedAndReplacedTasks() { 
     765            return detectedAndReplacedTasks; 
    733766        } 
    734767         
    … …  
    753786     * @author Patrick Harms 
    754787     */ 
    755     private static class Tasks implements Iterable<List<ITaskTreeNode>> { 
     788    private static class Tasks implements Iterable<List<ITaskInstance>> { 
    756789         
    757790        /** 
    … …  
    763796         *  
    764797         */ 
    765         private List<List<ITaskTreeNode>> sequences; 
     798        private List<List<ITaskInstance>> sequences; 
    766799 
    767800        /** 
    … …  
    769802         * @param sequences 
    770803         */ 
    771         private Tasks(int occurrenceCount, List<List<ITaskTreeNode>> sequences) { 
     804        private Tasks(int occurrenceCount, List<List<ITaskInstance>> sequences) { 
    772805            super(); 
    773806            this.occurrenceCount = occurrenceCount; 
    … …  
    797830         */ 
    798831        @Override 
    799         public Iterator<List<ITaskTreeNode>> iterator() { 
     832        public Iterator<List<ITaskInstance>> iterator() { 
    800833            return this.sequences.iterator(); 
    801834        } 
    … …  
    803836    } 
    804837 
     838    /** 
     839     * 
     840     */ 
     841    private class TaskComparator implements SymbolComparator<ITaskInstance> { 
     842 
     843        /** */ 
     844        private Comparer comparer; 
     845 
     846        /** */ 
     847        private Comparer lexicalComparer; 
     848 
     849        /** */ 
     850        private HashMap<Long, Boolean> equalityBuffer = new HashMap<Long, Boolean>(); 
     851 
     852        /** */ 
     853        private HashMap<Long, Boolean> lexicalEqualityBuffer; 
     854 
     855        /** 
     856         * 
     857         */ 
     858        public TaskComparator(TaskEqualityRuleManager taskEqualityRuleManager, 
     859                              TaskEquality            minimalNodeEquality) 
     860        { 
     861            super(); 
     862             
     863            if (minimalNodeEquality == TaskEquality.LEXICALLY_EQUAL) { 
     864                comparer = new LexicalComparer(taskEqualityRuleManager); 
     865            } 
     866            else if (minimalNodeEquality == TaskEquality.SYNTACTICALLY_EQUAL) { 
     867                comparer = new SyntacticalComparer(taskEqualityRuleManager); 
     868            } 
     869            else if (minimalNodeEquality == TaskEquality.SEMANTICALLY_EQUAL) { 
     870                comparer = new SemanticalComparer(taskEqualityRuleManager); 
     871            } 
     872            else { 
     873                comparer = new DefaultComparer(taskEqualityRuleManager, minimalNodeEquality); 
     874            } 
     875             
     876            if (minimalNodeEquality == TaskEquality.LEXICALLY_EQUAL) { 
     877                lexicalComparer = comparer; 
     878                lexicalEqualityBuffer = equalityBuffer; 
     879            } 
     880            else { 
     881                lexicalComparer = new LexicalComparer(taskEqualityRuleManager); 
     882                lexicalEqualityBuffer = new HashMap<Long, Boolean>(); 
     883            } 
     884        } 
     885 
     886        /* (non-Javadoc) 
     887         * @see de.ugoe.cs.autoquest.tasktrees.temporalrelation.SymbolComparator#equals(java.lang.Object, java.lang.Object) 
     888         */ 
     889        @Override 
     890        public boolean equals(ITaskInstance taskInstance1, ITaskInstance taskInstance2) { 
     891            return equals(taskInstance1.getTask(), taskInstance2.getTask()); 
     892        }         
     893 
     894        /** 
     895         *  
     896         */ 
     897        public boolean equals(ITask task1, ITask task2) { 
     898            Boolean result; 
     899             
     900            if (task1 != task2) { 
     901                if ((task1 instanceof IEventTask) && (task2 instanceof IEventTask)) { 
     902                    long key = ((long) System.identityHashCode(task1)) << 32; 
     903                    key += System.identityHashCode(task2); 
     904                 
     905                    result = equalityBuffer.get(key); 
     906                 
     907                    if (result == null) { 
     908                        result = comparer.compare(task1, task2); 
     909                        equalityBuffer.put(key, result); 
     910                    } 
     911                } 
     912                else { 
     913                    result = false; 
     914                } 
     915            } 
     916            else { 
     917                result = true; 
     918            } 
     919             
     920            return result; 
     921        } 
     922 
     923        /** 
     924         * 
     925         */ 
     926        public boolean areLexicallyEqual(ITask task1, ITask task2) { 
     927            Boolean result; 
     928             
     929            if (task1 != task2) { 
     930                long key = ((long) System.identityHashCode(task1)) << 32; 
     931                key += System.identityHashCode(task2); 
     932                 
     933                result = lexicalEqualityBuffer.get(key); 
     934                 
     935                if (result == null) { 
     936                    result = lexicalComparer.compare(task1, task2); 
     937                    lexicalEqualityBuffer.put(key, result); 
     938                } 
     939            } 
     940            else { 
     941                result = true; 
     942            } 
     943             
     944            return result; 
     945        } 
     946    } 
     947 
     948    /** 
     949     *  
     950     */ 
     951    private interface Comparer { 
     952         
     953        /** 
     954         *  
     955         */ 
     956        boolean compare(ITask task1, ITask task2); 
     957    } 
     958 
     959    /** 
     960     *  
     961     */ 
     962    private class LexicalComparer implements Comparer { 
     963         
     964        /** 
     965         * <p> 
     966         * the task equality manager needed for comparing tasks with each other 
     967         * </p> 
     968         */ 
     969        private TaskEqualityRuleManager taskEqualityRuleManager; 
     970         
     971        /** 
     972         * 
     973         */ 
     974        public LexicalComparer(TaskEqualityRuleManager taskEqualityRuleManager) { 
     975           this.taskEqualityRuleManager = taskEqualityRuleManager; 
     976        } 
     977         
     978        /** 
     979         *  
     980         */ 
     981        public boolean compare(ITask task1, ITask task2) { 
     982            return taskEqualityRuleManager.areLexicallyEqual(task1, task2); 
     983        } 
     984    } 
     985 
     986    /** 
     987     *  
     988     */ 
     989    private class SyntacticalComparer implements Comparer { 
     990         
     991        /** 
     992         * <p> 
     993         * the task equality manager needed for comparing tasks with each other 
     994         * </p> 
     995         */ 
     996        private TaskEqualityRuleManager taskEqualityRuleManager; 
     997         
     998        /** 
     999         * 
     1000         */ 
     1001        public SyntacticalComparer(TaskEqualityRuleManager taskEqualityRuleManager) { 
     1002           this.taskEqualityRuleManager = taskEqualityRuleManager; 
     1003        } 
     1004         
     1005        /** 
     1006         *  
     1007         */ 
     1008        public boolean compare(ITask task1, ITask task2) { 
     1009            return taskEqualityRuleManager.areSyntacticallyEqual(task1, task2); 
     1010        } 
     1011    } 
     1012 
     1013    /** 
     1014     *  
     1015     */ 
     1016    private class SemanticalComparer implements Comparer { 
     1017         
     1018        /** 
     1019         * <p> 
     1020         * the task equality manager needed for comparing tasks with each other 
     1021         * </p> 
     1022         */ 
     1023        private TaskEqualityRuleManager taskEqualityRuleManager; 
     1024         
     1025        /** 
     1026         * 
     1027         */ 
     1028        public SemanticalComparer(TaskEqualityRuleManager taskEqualityRuleManager) { 
     1029           this.taskEqualityRuleManager = taskEqualityRuleManager; 
     1030        } 
     1031         
     1032        /** 
     1033         *  
     1034         */ 
     1035        public boolean compare(ITask task1, ITask task2) { 
     1036            return taskEqualityRuleManager.areSemanticallyEqual(task1, task2); 
     1037        } 
     1038    } 
     1039 
     1040    /** 
     1041     *  
     1042     */ 
     1043    private class DefaultComparer implements Comparer { 
     1044         
     1045        /** 
     1046         * <p> 
     1047         * the task equality manager needed for comparing tasks with each other 
     1048         * </p> 
     1049         */ 
     1050        private TaskEqualityRuleManager taskEqualityRuleManager; 
     1051 
     1052        /** 
     1053         * <p> 
     1054         * the minimal task equality two identified sublists need to have to consider them as equal 
     1055         * </p> 
     1056         */ 
     1057        private TaskEquality minimalNodeEquality; 
     1058         
     1059        /** 
     1060         * 
     1061         */ 
     1062        public DefaultComparer(TaskEqualityRuleManager taskEqualityRuleManager, 
     1063                               TaskEquality            minimalNodeEquality) 
     1064        { 
     1065           this.taskEqualityRuleManager = taskEqualityRuleManager; 
     1066           this.minimalNodeEquality = minimalNodeEquality; 
     1067        } 
     1068         
     1069        /** 
     1070         *  
     1071         */ 
     1072        public boolean compare(ITask task1, ITask task2) { 
     1073            return taskEqualityRuleManager.areAtLeastEqual(task1, task2, minimalNodeEquality); 
     1074        } 
     1075    } 
    8051076} 

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

    r1131 r1146  
    2222import de.ugoe.cs.autoquest.eventcore.guimodel.IFrame; 
    2323import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement; 
    24 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; 
    25 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager; 
    26 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; 
    27 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
    28 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; 
     24import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; 
     25import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; 
     26import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; 
     27import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
     28import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
     29import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList; 
     30import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession; 
    2931import de.ugoe.cs.util.console.Console; 
    3032 
    3133/** 
     34 * TODO update comment 
     35 *  
    3236 * <p> 
    3337 * This class is responsible for applying temporal relationship rules on a task tree. Through this, 
    3438 * a flat task tree is restructured to have more depth but to include more temporal relationships 
    35  * between task tree nodes which are not only a major sequence. I.e. through the application of 
    36  * rule iterations and selections of task tree nodes are detected. Which kind of temporal relations 
    37  * between task tree nodes are detected depends on the {@link TemporalRelationshipRule}s known to 
     39 * between tasks which are not only a major sequence. I.e. through the application of the 
     40 * rules iterations and selections of tasks are detected. Which kind of temporal relations 
     41 * between tasks are detected depends on the {@link ITaskInstanceListScopeRule}s known to 
    3842 * this class. 
    3943 * </p> 
    40  * <p>The class holds references to the appropriate {@link TemporalRelationshipRule}s and calls 
    41  * their {@link TemporalRelationshipRule#apply(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)} 
    42  * method for each node in the task tree it is needed for. The general behavior of this class is 
     44 * <p>The class holds references to the appropriate {@link ITaskInstanceListScopeRule}s and calls 
     45 * their {@link ITaskInstanceListScopeRule#apply(ITask, ITaskBuilder, ITaskFactory, boolean)} 
     46 * method for each task in the task tree it is needed for. The general behavior of this class is 
    4347 * the following: 
    4448 * <ol> 
    … …  
    4852 *   </li> 
    4953 *   <li> 
    50  *     then the {@link #applyRules(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)} 
    51  *     method is called for a so far unstructured task tree node 
     54 *     then the {@link #applyRules(ITask, ITaskBuilder, ITaskFactory, boolean)} 
     55 *     method is called for a so far unstructured task 
    5256 *   </li> 
    5357 *   <li> 
    5458 *     the class iterates its internal list of rules and calls their 
    55  *     {@link TemporalRelationshipRule#apply(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)} 
     59 *     {@link ITaskInstanceListScopeRule#apply(ITask, ITaskBuilder, ITaskFactory, boolean)} 
    5660 *     method. 
    5761 *   </li> 
    … …  
    6973 *       <li> 
    7074 *         if a rule returns, that it was applied, the same rule is applied again until it returns 
    71  *         null or feasible. For each newly created parent node provided in the rule application 
    72  *         result, the {@link #applyRules(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)} 
     75 *         null or feasible. For each newly created parent task provided in the rule application 
     76 *         result, the {@link #applyRules(ITask, ITaskBuilder, ITaskFactory, boolean)} 
    7377 *         method is called. 
    7478 *       </li> 
    … …  
    7680 *   </li> 
    7781 * </ol> 
    78  * Through this, all rules are tried to be applied at least once to the provided parent node and 
    79  * all parent nodes created during the rule application. 
     82 * Through this, all rules are tried to be applied at least once to the provided parent task and 
     83 * all parent tasks created during the rule application. 
    8084 * </p> 
    8185 *  
    … …  
    8690    /** 
    8791     * <p> 
    88      * the node equality manager needed by the rules to compare task tree nodes with each other 
    89      * </p> 
    90      */ 
    91     private NodeEqualityRuleManager nodeEqualityRuleManager; 
    92  
    93     /** 
    94      * <p> 
    95      * the task tree node factory to be used during rule application 
    96      * </p> 
    97      */ 
    98     private ITaskTreeNodeFactory taskTreeNodeFactory; 
    99  
    100     /** 
    101      * <p> 
    102      * the task tree builder to be used during rule application 
    103      * </p> 
    104      */ 
    105     private ITaskTreeBuilder taskTreeBuilder; 
     92     * the task equality manager needed by the rules to compare tasks with each other 
     93     * </p> 
     94     */ 
     95    private TaskEqualityRuleManager taskEqualityRuleManager; 
     96 
     97    /** 
     98     * <p> 
     99     * the task factory to be used during rule application 
     100     * </p> 
     101     */ 
     102    private ITaskFactory taskFactory; 
     103 
     104    /** 
     105     * <p> 
     106     * the task builder to be used during rule application 
     107     * </p> 
     108     */ 
     109    private ITaskBuilder taskBuilder; 
     110 
     111    /** 
     112     * <p> 
     113     * the temporal relationship rules known to the manager that are executed on whole sessions. 
     114     * The rules are applied in the order they occur in this list. 
     115     * </p> 
     116     */ 
     117    private ISessionScopeRule[] sessionScopeRules; 
    106118 
    107119    /** 
    … …  
    111123     * </p> 
    112124     */ 
    113     private TemporalRelationshipRule[] treeScopeRules; 
    114  
    115     /** 
    116      * <p> 
    117      * the temporal relationship rules known to the manager that are executed on whole sub trees. 
    118      * The rules are applied in the order they occur in this list. 
    119      * </p> 
    120      */ 
    121     private TemporalRelationshipRule[] nodeScopeRules; 
     125    private ITaskInstanceListScopeRule[] taskScopeRules; 
    122126 
    123127    /** 
    … …  
    126130     * </p> 
    127131     *  
    128      * @param nodeEqualityRuleManager the node equality rule manager to be used by the known rules 
    129      *                                for task tree node comparison during rule application 
    130      * @param taskTreeNodeFactory     the node factory to be used for instantiating new task tree 
    131      *                                nodes during rule application 
    132      * @param taskTreeBuilder         the task tree builder to be used for linking task tree nodes 
     132     * @param taskEqualityRuleManager the task equality rule manager to be used by the known rules 
     133     *                                for task comparison during rule application 
     134     * @param taskFactory             the task factory to be used for instantiating new task tree 
     135     *                                tasks during rule application 
     136     * @param taskBuilder             the task builder to be used for linking tasks 
    133137     *                                with each other during rule application 
    134138     */ 
    135     public TemporalRelationshipRuleManager(NodeEqualityRuleManager nodeEqualityRuleManager, 
    136                                            ITaskTreeNodeFactory    taskTreeNodeFactory, 
    137                                            ITaskTreeBuilder        taskTreeBuilder) 
     139    public TemporalRelationshipRuleManager(TaskEqualityRuleManager taskEqualityRuleManager, 
     140                                           ITaskFactory            taskFactory, 
     141                                           ITaskBuilder            taskBuilder) 
    138142    { 
    139143        super(); 
    140         this.nodeEqualityRuleManager = nodeEqualityRuleManager; 
    141         this.taskTreeNodeFactory = taskTreeNodeFactory; 
    142         this.taskTreeBuilder = taskTreeBuilder; 
     144        this.taskEqualityRuleManager = taskEqualityRuleManager; 
     145        this.taskFactory = taskFactory; 
     146        this.taskBuilder = taskBuilder; 
    143147    } 
    144148 
    … …  
    146150     * <p> 
    147151     * initialized the temporal relationship rule manager by instantiating the known rules and 
    148      * providing them with a reference to the node equality manager or other information they need. 
     152     * providing them with a reference to the task equality manager or other information they need. 
    149153     * </p> 
    150154     */ 
    … …  
    156160        //frameFilter.add(ICanvas.class); 
    157161 
    158         treeScopeRules = new TemporalRelationshipRule[] { 
     162        sessionScopeRules = new ISessionScopeRule[] { 
    159163            new SequenceForTaskDetectionRule 
    160                 (nodeEqualityRuleManager, NodeEquality.SEMANTICALLY_EQUAL, 
    161                  taskTreeNodeFactory, taskTreeBuilder), 
     164                (taskEqualityRuleManager, TaskEquality.SEMANTICALLY_EQUAL, 
     165                 taskFactory, taskBuilder), 
    162166            /*new DefaultTaskSequenceDetectionRule 
    163                 (nodeEqualityRuleManager, NodeEquality.SYNTACTICALLY_EQUAL, 
    164                  taskTreeNodeFactory, taskTreeBuilder), 
     167                (taskEqualityRuleManager, NodeEquality.SYNTACTICALLY_EQUAL, 
     168                 taskFactory, taskTreeBuilder), 
    165169            new DefaultTaskSequenceDetectionRule 
    166                 (nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL, 
    167                  taskTreeNodeFactory, taskTreeBuilder),*/ 
     170                (taskEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL, 
     171                 taskFactory, taskTreeBuilder),*/ 
    168172            /*new TreeScopeWrapperRule 
    169173                (new DefaultIterationDetectionRule 
    170                     (nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL, 
    171                      taskTreeNodeFactory, taskTreeBuilder)), 
     174                    (taskEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL, 
     175                     taskFactory, taskTreeBuilder)), 
    172176            new TreeScopeWrapperRule 
    173177                (new DefaultIterationDetectionRule 
    174                     (nodeEqualityRuleManager, NodeEquality.SYNTACTICALLY_EQUAL, 
    175                      taskTreeNodeFactory, taskTreeBuilder)), 
     178                    (taskEqualityRuleManager, NodeEquality.SYNTACTICALLY_EQUAL, 
     179                     taskFactory, taskTreeBuilder)), 
    176180            new TreeScopeWrapperRule 
    177181                (new DefaultIterationDetectionRule 
    178                     (nodeEqualityRuleManager, NodeEquality.SEMANTICALLY_EQUAL, 
    179                      taskTreeNodeFactory, taskTreeBuilder))*/ 
     182                    (taskEqualityRuleManager, NodeEquality.SEMANTICALLY_EQUAL, 
     183                     taskFactory, taskTreeBuilder))*/ 
    180184        }; 
    181185         
    182186        //treeScopeRules.add(new DefaultGuiElementSequenceDetectionRule(frameFilter)); 
    183187 
    184         nodeScopeRules = new TemporalRelationshipRule[] { 
    185             //new SequenceOnGuiElementDetectionRule(taskTreeNodeFactory, taskTreeBuilder), 
    186             //new EventSequenceOnSameTargetDetectionRule(taskTreeNodeFactory, taskTreeBuilder), 
    187             new TrackBarSelectionDetectionRule 
    188                 (nodeEqualityRuleManager, taskTreeNodeFactory, taskTreeBuilder), 
    189             //new DefaultGuiEventSequenceDetectionRule(taskTreeNodeFactory, taskTreeBuilder), 
     188        taskScopeRules = new ITaskInstanceListScopeRule[] { 
     189            //new SequenceOnGuiElementDetectionRule(taskFactory, taskTreeBuilder), 
     190            //new EventSequenceOnSameTargetDetectionRule(taskFactory, taskTreeBuilder), 
     191            //new TrackBarSelectionDetectionRule(taskEqualityRuleManager, taskFactory, taskBuilder), 
     192            //new DefaultGuiEventSequenceDetectionRule(taskFactory, taskTreeBuilder), 
    190193        }; 
    191194 
    … …  
    194197    /** 
    195198     * <p> 
    196      * applies the known rules to the provided parent node. For the creation of further nodes, 
    197      * the provided builder and node factory are utilized. The method expectes, that no more data 
     199     * applies the known rules to the provided sessions. For the creation of further tasks, 
     200     * the provided builder and task factory are utilized. The method expects, that no more data 
    198201     * is available and, therefore, finalizes the rule application. 
    199202     * </p> 
    200203     *  
    201      * @param nodeFactory  the node factory to be used for instantiating new task tree nodes. 
    202      */ 
    203     public void applyRules(ITaskTreeNode parent) { 
    204         applyRules(parent, true); 
    205     } 
    206  
    207     /** 
    208      * <p> 
    209      * applies the known rules to the provided parent node. For the creation of further nodes, 
    210      * the provided builder and node factory are utilized. If the finalize parameter is true, the 
     204     * @param taskFactory  the task factory to be used for instantiating new tasks. 
     205     */ 
     206    public void applyRules(List<IUserSession> sessions) { 
     207        applyRules(sessionScopeRules, sessions, ""); 
     208    } 
     209 
     210    /** 
     211     * <p> 
     212     * applies the known rules to the provided parent task. For the creation of further tasks, 
     213     * the provided builder and task factory are utilized. If the finalize parameter is true, the 
    211214     * rule application is finalized as far as possible without waiting for further data. If it is 
    212215     * false, the rule application is broken up at the first rule returning, that its application 
    213      * would be feasible.  
     216     * would be feasible. The method calls itself for each parent task created through the rule 
     217     * application. In this case, the finalize parameter is always true. 
    214218     * </p> 
    215219     *  
    216      * @param parent       the parent node to apply the rules on 
    217      * @param finalize     used to indicate, if the rule application shall break up if a rule would 
    218      *                     be feasible if further data was available, or not. 
    219      */ 
    220     public void applyRules(ITaskTreeNode parent, boolean finalize) { 
    221         applyRules(treeScopeRules, parent, finalize, ""); 
    222     } 
    223  
    224     /** 
    225      * <p> 
    226      * applies the known rules to the provided parent node. For the creation of further nodes, 
    227      * the provided builder and node factory are utilized. If the finalize parameter is true, the 
    228      * rule application is finalized as far as possible without waiting for further data. If it is 
    229      * false, the rule application is broken up at the first rule returning, that its application 
    230      * would be feasible. The method calls itself for each parent node created through the rule 
    231      * application. In this case, the finalize parameter is always true. 
    232      * </p> 
    233      *  
    234      * @param parent       the parent node to apply the rules on 
     220     * @param parent       the parent task to apply the rules on 
    235221     * @param finalize     used to indicate, if the rule application shall break up if a rule would 
    236222     *                     be feasible if further data was available, or not. 
    … …  
    238224     *                     on the recursion depth of calling this method. 
    239225     */ 
    240     private int applyRules(TemporalRelationshipRule[] rules, 
    241                            ITaskTreeNode              parent, 
    242                            boolean                    finalize, 
    243                            String                     logIndent) 
     226    private int applyRules(ISessionScopeRule[] rules, 
     227                           List<IUserSession>  sessions, 
     228                           String              logIndent) 
    244229    { 
    245         Console.traceln(Level.FINER, logIndent + "applying rules for " + parent); 
     230        Console.traceln 
     231            (Level.FINER, logIndent + "applying rules for " + sessions.size() + " sessions"); 
    246232 
    247233        int noOfRuleApplications = 0; 
    248234 
    249         for (TemporalRelationshipRule rule : rules) { 
     235        for (ISessionScopeRule rule : rules) { 
    250236            RuleApplicationResult result; 
    251237            do { 
    252                 Console.traceln(Level.FINER, logIndent + "trying rule " + rule + " on " + parent); 
    253                 result = rule.apply(parent, finalize); 
     238                Console.traceln(Level.FINER, logIndent + "trying rule " + rule); 
     239                result = rule.apply(sessions); 
    254240 
    255241                if ((result != null) && 
    256242                    (result.getRuleApplicationStatus() == RuleApplicationStatus.FINISHED)) 
    257243                { 
    258                     Console.traceln 
    259                         (Level.FINE, logIndent + "applied rule " + rule + " on " + parent); 
     244                    Console.traceln(Level.FINE, logIndent + "applied rule " + rule); 
    260245                    noOfRuleApplications++; 
    261246                     
    262247                    //dumpTask(parent, ""); 
    263248 
    264                     for (ITaskTreeNode newParent : result.getNewlyCreatedParentNodes()) { 
     249                    for (ITaskInstance newParent : result.getNewlyCreatedTaskInstances()) { 
    265250                        noOfRuleApplications += 
    266                             applyRules(nodeScopeRules, newParent, true, logIndent + "  "); 
     251                            applyRules(taskScopeRules, newParent, logIndent + "  "); 
    267252                    } 
    268253                } 
    … …  
    271256                   (result.getRuleApplicationStatus() == RuleApplicationStatus.FINISHED)); 
    272257 
    273             if ((!finalize) && 
    274                 (result != null) && 
    275                 (result.getRuleApplicationStatus() == RuleApplicationStatus.FEASIBLE)) 
    276             { 
    277                 // in this case, don't go on applying rules, which should not be applied yet 
    278                 break; 
    279             } 
    280258        } 
    281259 
    … …  
    289267 
    290268    /** 
     269     * <p> 
     270     * applies the known rules to the provided parent task. For the creation of further tasks, 
     271     * the provided builder and task factory are utilized. If the finalize parameter is true, the 
     272     * rule application is finalized as far as possible without waiting for further data. If it is 
     273     * false, the rule application is broken up at the first rule returning, that its application 
     274     * would be feasible. The method calls itself for each parent task created through the rule 
     275     * application. In this case, the finalize parameter is always true. 
     276     * </p> 
     277     *  
     278     * @param parent       the parent task to apply the rules on 
     279     * @param finalize     used to indicate, if the rule application shall break up if a rule would 
     280     *                     be feasible if further data was available, or not. 
     281     * @param logIndent    simply used for logging purposes to indent the log messages depending 
     282     *                     on the recursion depth of calling this method. 
     283     */ 
     284    private int applyRules(ITaskInstanceListScopeRule[] rules, 
     285                           ITaskInstanceList            taskInstances, 
     286                           String                       logIndent) 
     287    { 
     288        Console.traceln(Level.FINER, logIndent + "applying rules for " + taskInstances.size() + 
     289                        " task instances"); 
     290 
     291        int noOfRuleApplications = 0; 
     292 
     293        for (ITaskInstanceListScopeRule rule : rules) { 
     294            RuleApplicationResult result; 
     295            do { 
     296                Console.traceln 
     297                    (Level.FINER, logIndent + "trying rule " + rule + " on " + taskInstances); 
     298                result = rule.apply(taskInstances); 
     299 
     300                if ((result != null) && 
     301                    (result.getRuleApplicationStatus() == RuleApplicationStatus.FINISHED)) 
     302                { 
     303                    Console.traceln 
     304                        (Level.FINE, logIndent + "applied rule " + rule + " on " + taskInstances); 
     305                    noOfRuleApplications++; 
     306                     
     307                    //dumpTask(parent, ""); 
     308 
     309                    for (ITaskInstance newParent : result.getNewlyCreatedTaskInstances()) { 
     310                        noOfRuleApplications += 
     311                            applyRules(taskScopeRules, newParent, logIndent + "  "); 
     312                    } 
     313                } 
     314            } 
     315            while ((result != null) && 
     316                   (result.getRuleApplicationStatus() == RuleApplicationStatus.FINISHED)); 
     317        } 
     318 
     319        if (noOfRuleApplications <= 0) { 
     320            Console.traceln(Level.FINE, logIndent + "no rules applied --> no temporal " + 
     321                            "relationship generated"); 
     322        } 
     323 
     324        return noOfRuleApplications; 
     325    } 
     326 
     327    /** 
    291328     * 
    292329     */ 
    293     /*private void dumpTask(ITaskTreeNode task, String indent) { 
     330    /*private void dumpTask(ITask task, String indent) { 
    294331        StringBuffer message = new StringBuffer(); 
    295332        message.append(indent); 
    … …  
    304341         
    305342        if ((task.getChildren() != null) && (task.getChildren().size() > 0)) { 
    306             for (ITaskTreeNode child : task.getChildren()) { 
     343            for (ITask child : task.getChildren()) { 
    307344                dumpTask(child, indent + "  "); 
    308345            } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/IEventTask.java

    r1114 r1146  
    2424 * @author 2011, last modified by $Author: $ 
    2525 */ 
    26 public interface IEventTask extends ITaskTreeNode { 
     26public interface IEventTask extends ITask { 
    2727     
    2828    /** 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/IIteration.java

    r1114 r1146  
    2121 * @author 2012, last modified by $Author: patrick$ 
    2222 */ 
    23 public interface IIteration extends ITemporalRelationship { 
     23public interface IIteration extends IMarkingTemporalRelationship { 
    2424 
    2525    /** 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/IOptional.java

    r1126 r1146  
    2121 * @author 2012, last modified by $Author: patrick$ 
    2222 */ 
    23 public interface IOptional extends ITemporalRelationship { 
     23public interface IOptional extends IMarkingTemporalRelationship { 
    2424 
    2525    /** 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ISelection.java

    r1114 r1146  
    2121 * @author 2012, last modified by $Author: patrick$ 
    2222 */ 
    23 public interface ISelection extends ITemporalRelationship { 
     23public interface ISelection extends IStructuringTemporalRelationship { 
    2424 
    2525    /** 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ISequence.java

    r1114 r1146  
    2121 * @author 2012, last modified by $Author: patrick$ 
    2222 */ 
    23 public interface ISequence extends ITemporalRelationship { 
     23public interface ISequence extends IStructuringTemporalRelationship { 
    2424 
    2525    /** 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskBuilder.java

    r1126 r1146  
    2121 * @author 2012, last modified by $Author: patrick$ 
    2222 */ 
    23 public interface ITaskTreeBuilder { 
     23public interface ITaskBuilder { 
    2424 
    2525    /** 
    26      * 
     26     * @param taskInstance 
     27     * @param child 
    2728     */ 
    28     void addChild(ISequence parent, ITaskTreeNode child); 
     29    void addChild(ITaskInstance taskInstance, ITaskInstance child) throws IllegalArgumentException; 
    2930 
    3031    /** 
     32     * <p> 
     33     * TODO: comment 
     34     * </p> 
    3135     * 
     36     * @param session 
     37     * @param taskInstance 
    3238     */ 
    33     void addChild(ISequence parent, int index, ITaskTreeNode child); 
     39    void addExecutedTask(IUserSession session, ITaskInstance taskInstance); 
    3440 
    3541    /** 
    … …  
    3844     * @param i 
    3945     */ 
    40     void setChild(ISequence parent, int index, ITaskTreeNode child); 
     46    void addTaskInstance(ITaskInstanceList taskInstanceList, ITaskInstance taskInstance); 
     47 
     48    /** 
     49     *  
     50     * @param parent 
     51     * @param i 
     52     */ 
     53    void addTaskInstance(ITaskInstanceList taskInstanceList, int index, ITaskInstance taskInstance); 
     54 
     55    /** 
     56     *  
     57     * @param parent 
     58     * @param i 
     59     */ 
     60    void setTaskInstance(ITaskInstanceList taskInstanceList, int index, ITaskInstance taskInstance); 
     61 
     62    /** 
     63     * <p> 
     64     * TODO: comment 
     65     * </p> 
     66     * 
     67     * @param instance2 
     68     * @param task 
     69     */ 
     70    void setTask(ITaskInstance taskInstance, ITask task); 
     71 
     72    /** 
     73     * 
     74     */ 
     75    void addChild(ISequence parent, ITask child); 
     76 
     77    /** 
     78     * 
     79     */ 
     80    void addChild(ISequence parent, int index, ITask child); 
     81 
     82    /** 
     83     *  
     84     * @param parent 
     85     * @param i 
     86     */ 
     87    void setChild(ISequence parent, int index, ITask child); 
    4188 
    4289    /** 
    … …  
    4491     * @param task 
    4592     */ 
    46     void addChild(ISelection parent, ITaskTreeNode child); 
     93    void addChild(ISelection parent, ITask child); 
    4794 
    4895    /** 
    … …  
    5198     * @param newChild 
    5299     */ 
    53     void setChild(IIteration iteration, ITaskTreeNode newChild); 
     100    void setMarkedTask(IIteration iteration, ITask newChild); 
    54101 
    55102    /** 
    … …  
    58105     * @param newChild 
    59106     */ 
    60     void setChild(IOptional optional, ITaskTreeNode newChild); 
     107    void setMarkedTask(IOptional optional, ITask newChild); 
    61108 
    62109    /** 
    … …  
    72119     * @param i 
    73120     */ 
    74     void removeChild(ISelection parent, ITaskTreeNode child); 
     121    void removeChild(ISelection parent, ITask child); 
     122 
     123    /** 
     124     *  
     125     * @param parent 
     126     * @param i 
     127     */ 
     128    void removeTaskInstance(ITaskInstanceList taskInstanceList, int index); 
    75129 
    76130    /** 
    … …  
    79133     * @param i 
    80134     */ 
    81     void replaceChild(ISelection parent, ITaskTreeNode oldChild, ITaskTreeNode newChild); 
     135    void replaceChild(ISelection parent, ITask oldChild, ITask newChild); 
    82136 
    83137    /** 
    … …  
    86140     * @param i 
    87141     */ 
    88     void setDescription(ITaskTreeNode node, String description); 
     142    void setDescription(ITask task, String description); 
    89143 
    90144} 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskFactory.java

    r1126 r1146  
    1515package de.ugoe.cs.autoquest.tasktrees.treeifc; 
    1616 
     17import java.util.List; 
     18 
    1719import de.ugoe.cs.autoquest.eventcore.IEventTarget; 
    1820import de.ugoe.cs.autoquest.eventcore.IEventType; 
    … …  
    2426 * @author 2012, last modified by $Author: patrick$ 
    2527 */ 
    26 public interface ITaskTreeNodeFactory 
    27 { 
     28public interface ITaskFactory { 
    2829 
    29   /** 
    30    * 
    31    * @param eventType 
    32    * @param eventTarget 
    33    * @return 
    34    */ 
    35   IEventTask createNewEventTask(IEventType eventType, IEventTarget eventTarget); 
     30    /** 
     31     *  
     32     * @param eventType 
     33     * @param eventTarget 
     34     * @return 
     35     */ 
     36    IEventTask createNewEventTask(IEventType eventType, IEventTarget eventTarget); 
    3637 
    37   /** 
    38    * 
    39    * @return 
    40    */ 
    41   ISequence createNewSequence(); 
     38    /** 
     39     *  
     40     * @return 
     41     */ 
     42    ISequence createNewSequence(); 
    4243 
    43   /** 
    44    * 
    45    * @return 
    46    */ 
    47   IIteration createNewIteration(); 
     44    /** 
     45     *  
     46     * @return 
     47     */ 
     48    IIteration createNewIteration(); 
    4849 
    49   /** 
    50    * 
    51    * @return 
    52    */ 
    53   IOptional createNewOptional(); 
     50    /** 
     51     *  
     52     * @return 
     53     */ 
     54    IOptional createNewOptional(); 
    5455 
    55   /** 
    56    * 
    57    * @return 
    58    */ 
    59   ISelection createNewSelection(); 
     56    /** 
     57     *  
     58     * @return 
     59     */ 
     60    ISelection createNewSelection(); 
    6061 
    61   /** 
    62    * 
    63    * @param rootSequence 
    64    * @return 
    65    */ 
    66   ITaskTree createTaskTree(ITaskTreeNode root); 
     62    /** 
     63     *  
     64     * @return 
     65     */ 
     66    ITaskInstance createNewTaskInstance(ITask task); 
     67 
     68    /** 
     69     * 
     70     * @return 
     71     */ 
     72    ITaskInstanceList createNewTaskInstanceList(); 
     73 
     74    /** 
     75     *  
     76     * @return 
     77     */ 
     78    IUserSession createUserSession(); 
     79 
     80    /** 
     81     *  
     82     * @param rootSequence 
     83     * @return 
     84     */ 
     85    ITaskModel createTaskModel(List<IUserSession> userSessions); 
    6786 
    6887} 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskInstance.java

    r1113 r1146  
    2323 * @author 2011, last modified by $Author: $ 
    2424 */ 
    25 public interface ITaskTreeNode extends Cloneable { 
     25public interface ITaskInstance extends ITaskInstanceList { 
    2626 
    2727    /** 
    2828     * 
    2929     */ 
    30     public String getName(); 
     30    public List<ITaskInstance> getChildren(); 
    3131 
    3232    /** 
    3333     * 
    3434     */ 
    35     public String getDescription(); 
     35    public ITask getTask(); 
    3636 
    3737    /** 
    3838     * 
    3939     */ 
    40     public List<ITaskTreeNode> getChildren(); 
    41  
    42     /** 
    43      * 
    44      */ 
    45     public boolean equals(ITaskTreeNode taskTreeNode); 
     40    public boolean equals(ITaskInstance taskInstance); 
    4641 
    4742    /** 
    … …  
    5348     * 
    5449     */ 
    55     public ITaskTreeNode clone(); 
    56      
     50    public ITaskInstance clone(); 
     51 
    5752} 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskModel.java

    r1114 r1146  
    1515package de.ugoe.cs.autoquest.tasktrees.treeifc; 
    1616 
    17 import java.util.Map; 
     17import java.io.Serializable; 
     18import java.util.Collection; 
     19import java.util.List; 
    1820 
    1921/** 
    … …  
    2325 * @author 2012, last modified by $Author: patrick$ 
    2426 */ 
    25 public interface ITaskTree extends Cloneable { 
     27public interface ITaskModel extends Cloneable, Serializable { 
    2628 
    2729    /** 
    2830     * 
    2931     */ 
    30     public ITaskTreeNode getRoot(); 
     32    public List<IUserSession> getUserSessions(); 
    3133 
    3234    /** 
    3335     * 
    3436     */ 
    35     public Map<ITaskTreeNode, ITaskTreeNodeInfo> getTaskMap(); 
     37    public Collection<ITask> getTasks(); 
    3638 
    3739    /** 
    3840     * 
    3941     */ 
    40     public ITaskTree clone(); 
     42    public ITaskInfo getTaskInfo(ITask task); 
     43 
     44    /** 
     45     * 
     46     */ 
     47    public ITaskModel clone(); 
    4148} 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITemporalRelationship.java

    r1113 r1146  
    2121 * @author 2012, last modified by $Author: patrick$ 
    2222 */ 
    23 public interface ITemporalRelationship extends ITaskTreeNode { 
     23public interface ITemporalRelationship extends ITask { 
    2424 
    2525    /** 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/EventTask.java

    r1126 r1146  
    1818import de.ugoe.cs.autoquest.eventcore.IEventType; 
    1919import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; 
    20 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
    2120 
    2221/** 
    … …  
    2625 * @author 2011, last modified by $Author: $ 
    2726 */ 
    28 public class EventTask extends TaskTreeNode implements IEventTask { 
     27class EventTask extends Task implements IEventTask { 
    2928     
     29    /**  */ 
     30    private static final long serialVersionUID = 1L; 
     31 
    3032    /** */ 
    3133    private IEventType eventType; 
    … …  
    3941     */ 
    4042    EventTask(IEventType eventType, IEventTarget eventTarget) { 
    41         super(eventType.toString()); 
    42         super.setDescription("executed on " + eventTarget); 
     43        super.setDescription(eventType.toString() + " executed on " + eventTarget); 
    4344        this.eventType = eventType; 
    4445        this.eventTarget = eventTarget; 
    … …  
    6263     * (non-Javadoc) 
    6364     *  
    64      * @see de.harms.ctte.Task#equals(de.harms.ctte.Task) 
    65      */ 
    66     @Override 
    67     public boolean equals(ITaskTreeNode task) { 
    68         if (!(task instanceof IEventTask)) { 
    69             return false; 
    70         } 
    71  
    72         IEventType otherType = ((IEventTask) task).getEventType(); 
    73         IEventTarget otherTarget = ((IEventTask) task).getEventTarget(); 
    74  
    75         if (((eventType == otherType) || 
    76              ((eventType != null) && (eventType.equals(otherType)))) && 
    77             ((eventTarget == otherTarget) || 
    78              ((eventTarget != null) && (eventTarget.equals(otherTarget))))) 
    79         { 
    80             return true; 
    81         } 
    82  
    83         return false; 
    84     } 
    85  
    86     /* 
    87      * (non-Javadoc) 
    88      *  
    8965     * @see de.harms.tasktrees.TreeNode#clone() 
    9066     */ 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Iteration.java

    r1126 r1146  
    1616 
    1717import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration; 
    18 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     18import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional; 
     19import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    1920 
    2021/** 
    … …  
    2425 * @author 2012, last modified by $Author: patrick$ 
    2526 */ 
    26 public class Iteration extends TaskTreeNode implements IIteration { 
     27class Iteration extends MarkingTemporalRelationship implements IIteration { 
     28 
     29    /**  */ 
     30    private static final long serialVersionUID = 1L; 
    2731 
    2832    /** 
    … …  
    3034     */ 
    3135    Iteration() { 
    32         super("Iteration"); 
     36        super("iteration"); 
    3337    } 
    3438 
    35     /* 
    36      * (non-Javadoc) 
    37      *  
    38      * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#addChild(TaskTreeNode) 
     39    /* (non-Javadoc) 
     40     * @see MarkingTemporalRelationship#setMarkedTask(ITask) 
    3941     */ 
    4042    @Override 
    41     public void addChild(ITaskTreeNode child) { 
    42         // adding more children is not allowed 
    43         throw new UnsupportedOperationException 
    44             ("iterations may not have a list of children. Use setChild() instead."); 
    45     } 
    46  
    47     /** 
    48      * TODO: comment 
    49      *  
    50      * @param selection 
    51      * @return 
    52      */ 
    53     public void setChild(ITaskTreeNode child) { 
    54         if (super.getChildren().size() > 0) { 
    55             super.removeChild(0); 
     43    protected void setMarkedTask(ITask markedTask) { 
     44        if (markedTask instanceof IIteration) { 
     45            throw new IllegalArgumentException 
     46                ("the marked task of an iteration must not be an iteration"); 
    5647        } 
    57         super.addChild(child); 
     48        else if (markedTask instanceof IOptional) { 
     49            throw new IllegalArgumentException 
     50                ("the marked task of an iteration must not be an optional"); 
     51        } 
     52         
     53        super.setMarkedTask(markedTask); 
    5854    } 
    5955 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Optional.java

    r1126 r1146  
    1616 
    1717import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional; 
    18 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     18import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    1919 
    2020/** 
    … …  
    2424 * @author 2012, last modified by $Author: patrick$ 
    2525 */ 
    26 public class Optional extends TaskTreeNode implements IOptional { 
     26class Optional extends MarkingTemporalRelationship implements IOptional { 
     27 
     28    /**  */ 
     29    private static final long serialVersionUID = 1L; 
    2730 
    2831    /** 
    … …  
    3033     */ 
    3134    Optional() { 
    32         super("Optional"); 
     35        super("optionality"); 
    3336    } 
    34  
    35     /* 
    36      * (non-Javadoc) 
    37      *  
    38      * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#addChild(TaskTreeNode) 
     37     
     38    /* (non-Javadoc) 
     39     * @see MarkingTemporalRelationship#setMarkedTask(ITask) 
    3940     */ 
    4041    @Override 
    41     public void addChild(ITaskTreeNode child) { 
    42         // adding more children is not allowed 
    43         throw new UnsupportedOperationException 
    44             ("optionalities may not have a list of children. Use setChild() instead."); 
    45     } 
    46  
    47     /** 
    48      * TODO: comment 
    49      *  
    50      * @param selection 
    51      * @return 
    52      */ 
    53     public void setChild(ITaskTreeNode child) { 
    54         if (super.getChildren().size() > 0) { 
    55             super.removeChild(0); 
     42    protected void setMarkedTask(ITask markedTask) { 
     43        if (markedTask instanceof IOptional) { 
     44            throw new IllegalArgumentException 
     45                ("the marked task of an optional must not be an optional"); 
    5646        } 
    57         super.addChild(child); 
     47         
     48        super.setMarkedTask(markedTask); 
    5849    } 
    5950 
    … …  
    6758        return (Optional) super.clone(); 
    6859    } 
    69  
    7060} 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Selection.java

    r1113 r1146  
    1616 
    1717import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; 
     18import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    1819 
    1920/** 
    … …  
    2324 * @author 2012, last modified by $Author: patrick$ 
    2425 */ 
    25 public class Selection extends TaskTreeNode implements ISelection { 
     26class Selection extends StructuringTemporalRelationship implements ISelection { 
     27 
     28    /**  */ 
     29    private static final long serialVersionUID = 1L; 
    2630 
    2731    /** 
    … …  
    3135     */ 
    3236    Selection() { 
    33         super("Selection"); 
     37        super("selection"); 
    3438    } 
    3539 
    … …  
    4448    } 
    4549 
     50    /** 
     51     * <p> 
     52     * TODO: comment 
     53     * </p> 
     54     * 
     55     * @param i 
     56     * @param newChild 
     57     */ 
     58    public void addChild(ITask newChild) { 
     59        super.addChild(newChild); 
     60        super.setDescription("selection of " + newChild); 
     61    } 
     62 
     63    /** 
     64     * <p> 
     65     * TODO: comment 
     66     * </p> 
     67     * 
     68     * @param i 
     69     * @param newChild 
     70     */ 
     71    public void addChild(int index, ITask newChild) { 
     72        super.addChild(index, newChild); 
     73        super.setDescription("selection of " + newChild); 
     74    } 
     75 
    4676} 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Sequence.java

    r1113 r1146  
    2323 * @author 2012, last modified by $Author: patrick$ 
    2424 */ 
    25 public class Sequence extends TaskTreeNode implements ISequence { 
     25class Sequence extends StructuringTemporalRelationship implements ISequence { 
    2626     
     27    /**  */ 
     28    private static final long serialVersionUID = 1L; 
     29 
    2730    /** 
    2831     * TODO: comment 
    … …  
    3134     */ 
    3235    Sequence() { 
    33         super("Sequence"); 
    34     } 
    35  
    36     /** 
    37      * TODO: comment 
    38      *  
    39      * @param name 
    40      */ 
    41     Sequence(String name) { 
    42         super(name); 
     36        super("sequence"); 
    4337    } 
    4438 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Task.java

    r1126 r1146  
    1515package de.ugoe.cs.autoquest.tasktrees.treeimpl; 
    1616 
    17 import java.util.Collections; 
    18 import java.util.LinkedList; 
    19 import java.util.List; 
    20  
    21 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     17import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2218 
    2319/** 
    … …  
    2723 * @author 2011, last modified by $Author: $ 
    2824 */ 
    29 public class TaskTreeNode implements ITaskTreeNode { 
     25class Task implements ITask { 
     26 
     27    /**  */ 
     28    private static final long serialVersionUID = 1L; 
     29 
    3030    /** */ 
    3131    private static int temporalId = 0; 
    3232 
    3333    /** */ 
    34     private String name; 
     34    private int id; 
    3535 
    3636    /** */ 
    3737    private String description; 
    3838 
    39     /** */ 
    40     private int id; 
    41  
    42     /** children */ 
    43     private List<ITaskTreeNode> children; 
    44  
    4539    /** 
    4640     *  
    4741     */ 
    48     public TaskTreeNode(String name) { 
    49         this.name = name; 
     42    Task() { 
    5043        id = getNewId(); 
    5144    } 
    … …  
    6760     * @return Returns the name. 
    6861     */ 
    69     public String getName() { 
    70         return name; 
     62    public int getId() { 
     63        return id; 
    7164    } 
    7265 
    … …  
    8174    } 
    8275 
    83     /** 
    84      *  
    85      */ 
    86     public synchronized List<ITaskTreeNode> getChildren() { 
    87         if ((children == null) || (children.size() == 0)) { 
    88             return new LinkedList<ITaskTreeNode>(); 
    89         } 
    90  
    91         return Collections.unmodifiableList(children); 
    92     } 
    93  
    9476    /* 
    9577     * (non-Javadoc) 
    … …  
    9880     */ 
    9981    @Override 
    100     public boolean equals(ITaskTreeNode taskTreeNode) { 
    101         if (!this.getClass().isInstance(taskTreeNode)) { 
    102             return false; 
    103         } 
    104  
    105         if (taskTreeNode.hashCode() != hashCode()) { 
    106             return false; 
    107         } 
    108  
    109         TaskTreeNode other = (TaskTreeNode) taskTreeNode; 
    110  
    111         if (id != other.id) { 
    112             return false; 
    113         } 
    114  
    115         if (!name.equals(other.name)) { 
    116             return false; 
    117         } 
    118  
    119         synchronized (other) { 
    120             if (children == null) { 
    121                 return (other.children == null); 
    122             } 
    123             else if (other.children == null) { 
    124                 return (children == null); 
    125             } 
    126             else if (other.children.size() != children.size()) { 
    127                 return false; 
    128             } 
    129  
    130             for (int i = 0; i < children.size(); i++) { 
    131                 if (!children.get(i).equals(other.children.get(i))) { 
    132                     return false; 
    133                 } 
    134             } 
    135         } 
    136  
    137         return true; 
     82    public final boolean equals(ITask task) { 
     83        // tasks are only equal if they are identical or if they have the same id 
     84        // (may happen, if they are cloned) 
     85        return (this == task) || (this.hashCode() == task.hashCode()); 
    13886    } 
    13987 
    … …  
    14593    @Override 
    14694    public synchronized int hashCode() { 
    147         return getClass().getSimpleName().hashCode(); 
     95        return id; 
    14896    } 
    14997 
    … …  
    156104    public synchronized String toString() { 
    157105        StringBuffer result = new StringBuffer(); 
    158         result.append(name); 
    159         result.append('('); 
     106        result.append("task "); 
    160107        result.append(id); 
    161108         
    162109        if (description != null) { 
    163             result.append(", "); 
     110            result.append(" ("); 
    164111            result.append(description); 
     112            result.append(')'); 
    165113        } 
    166114         
    167         if (children != null) { 
    168             result.append(", "); 
    169             result.append(children.size()); 
    170             result.append(" children"); 
     115        return result.toString(); 
     116    } 
     117 
     118    /* 
     119     * (non-Javadoc) 
     120     *  
     121     * @see java.lang.Object#clone() 
     122     */ 
     123    @Override 
     124    public synchronized ITask clone() { 
     125        Task clone = null; 
     126        try { 
     127            clone = (Task) super.clone(); 
    171128        } 
    172          
    173         result.append(')'); 
    174         return result.toString(); 
     129        catch (CloneNotSupportedException e) { 
     130            // this should never happen. Therefore simply dump the exception 
     131            e.printStackTrace(); 
     132        } 
     133 
     134        return clone; 
    175135    } 
    176136 
    … …  
    185145    } 
    186146 
    187     /** 
    188      *  
    189      */ 
    190     synchronized void addChild(ITaskTreeNode child) { 
    191         if (children == null) { 
    192             children = new LinkedList<ITaskTreeNode>(); 
    193         } 
    194  
    195         children.add(child); 
    196     } 
    197  
    198     /** 
    199      *  
    200      */ 
    201     synchronized void addChild(int index, ITaskTreeNode child) { 
    202         if (children == null) { 
    203             children = new LinkedList<ITaskTreeNode>(); 
    204         } 
    205  
    206         children.add(index, child); 
    207     } 
    208  
    209     /** 
    210      * TODO: comment 
    211      *  
    212      * @param i 
    213      * @return 
    214      */ 
    215     synchronized ITaskTreeNode removeChild(int index) { 
    216         return children.remove(index); 
    217     } 
    218  
    219     /* 
    220      * (non-Javadoc) 
    221      *  
    222      * @see java.lang.Object#clone() 
    223      */ 
    224     @Override 
    225     public synchronized ITaskTreeNode clone() { 
    226         TaskTreeNode clone = null; 
    227         try { 
    228             clone = (TaskTreeNode) super.clone(); 
    229  
    230             if (children != null) { 
    231                 clone.children = new LinkedList<ITaskTreeNode>(); 
    232  
    233                 for (ITaskTreeNode child : children) { 
    234                     clone.children.add(child.clone()); 
    235                 } 
    236             } 
    237  
    238         } 
    239         catch (CloneNotSupportedException e) { 
    240             // this should never happen. Therefore simply dump the exception 
    241             e.printStackTrace(); 
    242         } 
    243  
    244         return clone; 
    245     } 
    246  
    247147} 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskBuilder.java

    r1126 r1146  
    1717import java.util.List; 
    1818 
     19import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; 
    1920import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration; 
    2021import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional; 
    2122import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; 
    2223import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    23 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; 
    24 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
     24import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
     25import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; 
     26import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
     27import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList; 
     28import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession; 
    2529 
    2630/** 
    … …  
    3034 * @author 2012, last modified by $Author: patrick$ 
    3135 */ 
    32 public class TaskTreeBuilder implements ITaskTreeBuilder { 
     36public class TaskBuilder implements ITaskBuilder { 
     37 
     38    /* (non-Javadoc) 
     39     * @see ITaskBuilder#addChild(ITaskInstance, ITaskInstance) 
     40     */ 
     41    @Override 
     42    public void addChild(ITaskInstance parent, ITaskInstance child) throws IllegalArgumentException 
     43    { 
     44        if (!(parent instanceof TaskInstance)) { 
     45            throw new IllegalArgumentException 
     46                ("illegal type of task instance provided: " + parent.getClass()); 
     47        } 
     48 
     49        if (!(child instanceof TaskInstance)) { 
     50            throw new IllegalArgumentException 
     51                ("illegal type of task instance provided: " + parent.getClass()); 
     52        } 
     53         
     54        // check, that the correct number of children for the distinct types are added 
     55        ITask task = parent.getTask(); 
     56         
     57        if (task instanceof IEventTask) { 
     58            throw new IllegalArgumentException 
     59                ("can not add children to a task instance of an event task"); 
     60        } 
     61        else if (task instanceof ISelection) { 
     62            if (parent.getChildren().size() > 0) { 
     63                throw new IllegalArgumentException 
     64                    ("the instance of a selection must have at most one child"); 
     65            } 
     66        } 
     67        else if (task instanceof IOptional) { 
     68            if (parent.getChildren().size() > 1) { 
     69                throw new IllegalArgumentException 
     70                    ("the instance of an optional must have at most one child"); 
     71            } 
     72        } 
     73/*        else if (task instanceof IIteration) { 
     74            for (ITaskInstance childInstance : parent.getChildren()) { 
     75                if (!childInstance.getTask().equals(child.getTask())) { 
     76                    throw new IllegalArgumentException 
     77                        ("all children of an instance of an iteration must have exactly the " + 
     78                         "same type"); 
     79                } 
     80            } 
     81        } 
     82         
     83        boolean foundChildTask = false; 
     84        if (parent.getTask() instanceof IStructuringTemporalRelationship) { 
     85            IStructuringTemporalRelationship parentTask = 
     86                (IStructuringTemporalRelationship) parent.getTask(); 
     87         
     88            for (ITask parentTaskChild : parentTask.getChildren()) { 
     89                if (parentTaskChild.equals(child.getTask())) { 
     90                    foundChildTask = true; 
     91                    break; 
     92                } 
     93            } 
     94        } 
     95        else if (parent.getTask() instanceof IMarkingTemporalRelationship) { 
     96            IMarkingTemporalRelationship parentTask = 
     97                (IMarkingTemporalRelationship) parent.getTask(); 
     98             
     99            foundChildTask = parentTask.getMarkedTask() != null ? 
     100                parentTask.getMarkedTask().equals(child.getTask()) : false; 
     101        } 
     102         
     103        if (!foundChildTask) { 
     104            throw new IllegalArgumentException 
     105                ("the task of the child instance to be added does not belong to the children " + 
     106                 "of the task of the parent instance"); 
     107        }*/ 
     108 
     109        // finally, after all checks are positive, add the child 
     110        ((TaskInstance) parent).addChild(child); 
     111    } 
     112 
     113    /* (non-Javadoc) 
     114     * @see ITaskBuilder#addExecutedTask(IUserSession, ITaskInstance) 
     115     */ 
     116    @Override 
     117    public void addExecutedTask(IUserSession session, ITaskInstance taskInstance) { 
     118        if (!(session instanceof UserSession)) { 
     119            throw new IllegalArgumentException 
     120                ("illegal type of session provided: " + session.getClass()); 
     121        } 
     122 
     123        if (!(taskInstance instanceof TaskInstance)) { 
     124            throw new IllegalArgumentException 
     125                ("illegal type of task instance provided: " + taskInstance.getClass()); 
     126        } 
     127         
     128        ((UserSession) session).addExecutedTask(taskInstance); 
     129    } 
     130 
     131    /* (non-Javadoc) 
     132     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder#addTaskInstance(de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList, de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance) 
     133     */ 
     134    @Override 
     135    public void addTaskInstance(ITaskInstanceList taskInstanceList, ITaskInstance taskInstance) { 
     136        if (taskInstanceList instanceof TaskInstance) { 
     137            ((TaskInstance) taskInstanceList).addChild(taskInstance); 
     138        } 
     139        else if (taskInstanceList instanceof UserSession) { 
     140            ((UserSession) taskInstanceList).addExecutedTask(taskInstance); 
     141        } 
     142        else { 
     143            throw new IllegalArgumentException 
     144                ("illegal type of task instance list provided: " + taskInstanceList.getClass()); 
     145        } 
     146    } 
     147 
     148    /* (non-Javadoc) 
     149     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder#addTaskInstance(de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList, int, de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance) 
     150     */ 
     151    @Override 
     152    public void addTaskInstance(ITaskInstanceList taskInstanceList, 
     153                                int               index, 
     154                                ITaskInstance     taskInstance) 
     155    { 
     156        if (taskInstanceList instanceof TaskInstance) { 
     157            ((TaskInstance) taskInstanceList).addChild(index, taskInstance); 
     158        } 
     159        else if (taskInstanceList instanceof UserSession) { 
     160            ((UserSession) taskInstanceList).addExecutedTask(index, taskInstance); 
     161        } 
     162        else { 
     163            throw new IllegalArgumentException 
     164                ("illegal type of task instance list provided: " + taskInstanceList.getClass()); 
     165        } 
     166    } 
     167 
     168    /* (non-Javadoc) 
     169     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder#setTaskInstance(de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList, int, de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance) 
     170     */ 
     171    @Override 
     172    public void setTaskInstance(ITaskInstanceList taskInstanceList, 
     173                                int               index, 
     174                                ITaskInstance     taskInstance) 
     175    { 
     176        if (taskInstanceList instanceof TaskInstance) { 
     177            ((TaskInstance) taskInstanceList).removeChild(index); 
     178            ((TaskInstance) taskInstanceList).addChild(index, taskInstance); 
     179        } 
     180        else if (taskInstanceList instanceof UserSession) { 
     181            ((UserSession) taskInstanceList).removeExecutedTask(index); 
     182            ((UserSession) taskInstanceList).addExecutedTask(index, taskInstance); 
     183        } 
     184        else { 
     185            throw new IllegalArgumentException 
     186                ("illegal type of task instance list provided: " + taskInstanceList.getClass()); 
     187        } 
     188    } 
     189 
     190    /* (non-Javadoc) 
     191     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder#setTask(de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance, de.ugoe.cs.autoquest.tasktrees.treeifc.ITask) 
     192     */ 
     193    @Override 
     194    public void setTask(ITaskInstance taskInstance, ITask task) { 
     195        if (!(taskInstance instanceof TaskInstance)) { 
     196            throw new IllegalArgumentException 
     197                ("illegal type of task instance provided: " + taskInstance.getClass()); 
     198        } 
     199         
     200        ((TaskInstance) taskInstance).setTask(task); 
     201    } 
    33202 
    34203    /* 
    … …  
    38207     */ 
    39208    @Override 
    40     public void addChild(ISequence parent, ITaskTreeNode child) { 
     209    public void addChild(ISequence parent, ITask child) { 
    41210        if (!(parent instanceof Sequence)) { 
    42211            throw new IllegalArgumentException 
    43                 ("illegal type of task tree node provided: " + parent.getClass()); 
    44         } 
    45  
    46         addChildInternal(parent, -1, child); 
     212                ("illegal type of sequence provided: " + parent.getClass()); 
     213        } 
     214 
     215        addChildInternal((Sequence) parent, -1, child); 
    47216    } 
    48217 
    … …  
    53222     */ 
    54223    @Override 
    55     public void addChild(ISequence parent, int index, ITaskTreeNode child) { 
     224    public void addChild(ISequence parent, int index, ITask child) { 
    56225        if (!(parent instanceof Sequence)) { 
    57226            throw new IllegalArgumentException 
    58                 ("illegal type of task tree node provided: " + parent.getClass()); 
    59         } 
    60  
    61         addChildInternal(parent, index, child); 
     227                ("illegal type of sequence provided: " + parent.getClass()); 
     228        } 
     229 
     230        addChildInternal((Sequence) parent, index, child); 
    62231    } 
    63232 
    … …  
    66235     */ 
    67236    @Override 
    68     public void setChild(ISequence parent, int index, ITaskTreeNode child) { 
     237    public void setChild(ISequence parent, int index, ITask child) { 
    69238        if (!(parent instanceof Sequence)) { 
    70239            throw new IllegalArgumentException 
    71                 ("illegal type of task tree node provided: " + parent.getClass()); 
    72         } 
    73  
    74         ((TaskTreeNode) parent).removeChild(index); 
    75         addChildInternal(parent, index, child); 
     240                ("illegal type of sequence provided: " + parent.getClass()); 
     241        } 
     242 
     243        ((Sequence) parent).removeChild(index); 
     244        addChildInternal((Sequence) parent, index, child); 
    76245    } 
    77246 
    … …  
    82251     */ 
    83252    @Override 
    84     public void addChild(ISelection parent, ITaskTreeNode child) { 
     253    public void addChild(ISelection parent, ITask child) { 
    85254        if (!(parent instanceof Selection)) { 
    86255            throw new IllegalArgumentException 
    87                 ("illegal type of task tree node provided: " + parent.getClass()); 
    88         } 
    89  
    90         addChildInternal(parent, -1, child); 
     256                ("illegal type of selection provided: " + parent.getClass()); 
     257        } 
     258 
     259        addChildInternal((Selection) parent, -1, child); 
    91260    } 
    92261 
    … …  
    97266     */ 
    98267    @Override 
    99     public void setChild(IIteration iteration, ITaskTreeNode newChild) { 
     268    public void setMarkedTask(IIteration iteration, ITask newChild) { 
    100269        if (!(iteration instanceof Iteration)) { 
    101270            throw new IllegalArgumentException 
    … …  
    103272        } 
    104273 
    105         if (!(newChild instanceof TaskTreeNode)) { 
    106             throw new IllegalArgumentException 
    107                 ("illegal type of task tree node provided: " + newChild.getClass()); 
    108         } 
    109  
    110         ((Iteration) iteration).setChild(newChild); 
     274        if (!(newChild instanceof Task)) { 
     275            throw new IllegalArgumentException 
     276                ("illegal type of task provided: " + newChild.getClass()); 
     277        } 
     278 
     279        ((Iteration) iteration).setMarkedTask(newChild); 
    111280    } 
    112281 
    … …  
    115284     */ 
    116285    @Override 
    117     public void setChild(IOptional optional, ITaskTreeNode newChild) { 
     286    public void setMarkedTask(IOptional optional, ITask newChild) { 
    118287        if (!(optional instanceof Optional)) { 
    119288            throw new IllegalArgumentException 
    … …  
    121290        } 
    122291 
    123         if (!(newChild instanceof TaskTreeNode)) { 
    124             throw new IllegalArgumentException 
    125                 ("illegal type of task tree node provided: " + newChild.getClass()); 
    126         } 
    127  
    128         ((Optional) optional).setChild(newChild); 
     292        if (!(newChild instanceof Task)) { 
     293            throw new IllegalArgumentException 
     294                ("illegal type of task provided: " + newChild.getClass()); 
     295        } 
     296 
     297        ((Optional) optional).setMarkedTask(newChild); 
    129298    } 
    130299 
    … …  
    136305    @Override 
    137306    public void removeChild(ISequence parent, int index) { 
    138         if (!(parent instanceof TaskTreeNode)) { 
    139             throw new IllegalArgumentException 
    140                 ("illegal type of task tree node provided: " + parent.getClass()); 
    141         } 
    142  
    143         ((TaskTreeNode) parent).removeChild(index); 
     307        if (!(parent instanceof Sequence)) { 
     308            throw new IllegalArgumentException 
     309                ("illegal type of sequence provided: " + parent.getClass()); 
     310        } 
     311 
     312        ((Sequence) parent).removeChild(index); 
    144313    } 
    145314 
    … …  
    150319     */ 
    151320    @Override 
    152     public void removeChild(ISelection parent, ITaskTreeNode child) { 
    153         if (!(parent instanceof TaskTreeNode)) { 
    154             throw new IllegalArgumentException 
    155                 ("illegal type of task tree node provided: " + parent.getClass()); 
    156         } 
    157  
    158         List<ITaskTreeNode> children = parent.getChildren(); 
     321    public void removeChild(ISelection parent, ITask child) { 
     322        if (!(parent instanceof Selection)) { 
     323            throw new IllegalArgumentException 
     324                ("illegal type of selection provided: " + parent.getClass()); 
     325        } 
     326 
     327        List<ITask> children = parent.getChildren(); 
    159328         
    160329        for (int i = 0; i < children.size(); i++) { 
    … …  
    162331                ((children.get(i) != null) && (children.get(i).equals(child)))) 
    163332            { 
    164                 ((TaskTreeNode) parent).removeChild(i); 
     333                ((Selection) parent).removeChild(i); 
    165334                break; 
    166335            } 
    … …  
    169338 
    170339    /* (non-Javadoc) 
     340     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder#removeTaskInstance(de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList, int) 
     341     */ 
     342    @Override 
     343    public void removeTaskInstance(ITaskInstanceList taskInstanceList, int index) { 
     344        if (taskInstanceList instanceof TaskInstance) { 
     345            ((TaskInstance) taskInstanceList).removeChild(index); 
     346        } 
     347        else if (taskInstanceList instanceof UserSession) { 
     348            ((UserSession) taskInstanceList).removeExecutedTask(index); 
     349        } 
     350        else { 
     351            throw new IllegalArgumentException 
     352                ("illegal type of task instance list provided: " + taskInstanceList.getClass()); 
     353        } 
     354    } 
     355 
     356    /* (non-Javadoc) 
    171357     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder#replaceChild(de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection, de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode, de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode) 
    172358     */ 
    173359    @Override 
    174     public void replaceChild(ISelection parent, ITaskTreeNode oldChild, ITaskTreeNode newChild) { 
    175         if (!(parent instanceof TaskTreeNode)) { 
    176             throw new IllegalArgumentException 
    177                 ("illegal type of task tree node provided: " + parent.getClass()); 
    178         } 
    179  
    180         List<ITaskTreeNode> children = parent.getChildren(); 
     360    public void replaceChild(ISelection parent, ITask oldChild, ITask newChild) { 
     361        if (!(parent instanceof Selection)) { 
     362            throw new IllegalArgumentException 
     363                ("illegal type of selection provided: " + parent.getClass()); 
     364        } 
     365 
     366        List<ITask> children = parent.getChildren(); 
    181367         
    182368        for (int i = 0; i < children.size(); i++) { 
    … …  
    184370                ((children.get(i) != null) && (children.get(i).equals(oldChild)))) 
    185371            { 
    186                 ((TaskTreeNode) parent).removeChild(i); 
    187                 ((TaskTreeNode) parent).addChild(i, newChild); 
     372                ((Selection) parent).removeChild(i); 
     373                ((Selection) parent).addChild(i, newChild); 
    188374                break; 
    189375            } 
    … …  
    197383     */ 
    198384    @Override 
    199     public void setDescription(ITaskTreeNode parent, String description) { 
    200         if (!(parent instanceof TaskTreeNode)) { 
    201             throw new IllegalArgumentException 
    202                 ("illegal type of task tree node provided: " + parent.getClass()); 
    203         } 
    204  
    205         ((TaskTreeNode) parent).setDescription(description); 
     385    public void setDescription(ITask parent, String description) { 
     386        if (!(parent instanceof Task)) { 
     387            throw new IllegalArgumentException 
     388                ("illegal type of task provided: " + parent.getClass()); 
     389        } 
     390 
     391        ((Task) parent).setDescription(description); 
    206392    } 
    207393 
    … …  
    209395     *  
    210396     */ 
    211     private void addChildInternal(ITaskTreeNode parent, int index, ITaskTreeNode child) { 
    212         if (!(child instanceof TaskTreeNode)) { 
    213             throw new IllegalArgumentException 
    214                 ("illegal type of task tree node provided: " + child.getClass()); 
     397    private void addChildInternal(StructuringTemporalRelationship parent, int index, ITask child) { 
     398        if (!(child instanceof Task)) { 
     399            throw new IllegalArgumentException 
     400                ("illegal type of task provided: " + child.getClass()); 
    215401        } 
    216402 
    217403        if (index > -1) { 
    218             ((TaskTreeNode) parent).addChild(index, child); 
     404            parent.addChild(index, child); 
    219405        } 
    220406        else { 
    221             ((TaskTreeNode) parent).addChild(child); 
     407            parent.addChild(child); 
    222408        } 
    223409    } 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskFactory.java

    r1126 r1146  
    1515package de.ugoe.cs.autoquest.tasktrees.treeimpl; 
    1616 
     17import java.util.List; 
     18 
    1719import de.ugoe.cs.autoquest.eventcore.IEventTarget; 
    1820import de.ugoe.cs.autoquest.eventcore.IEventType; 
    … …  
    2224import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; 
    2325import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    24 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; 
    25 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
    26 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; 
     26import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
     27import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
     28import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList; 
     29import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
     30import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
     31import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession; 
    2732 
    2833/** 
    … …  
    3237 * @author 2012, last modified by $Author: patrick$ 
    3338 */ 
    34 public class TaskTreeNodeFactory implements ITaskTreeNodeFactory { 
     39public class TaskFactory implements ITaskFactory { 
    3540 
    3641    /* 
    … …  
    8287    } 
    8388 
    84     /* 
    85      * (non-Javadoc) 
    86      *  
    87      * @see 
    88      * de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createTaskTree(de.ugoe.cs.tasktree.treeifc 
    89      * .TaskTreeNode) 
     89    /* (non-Javadoc) 
     90     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory#createNewTaskInstance(ITask) 
    9091     */ 
    9192    @Override 
    92     public ITaskTree createTaskTree(ITaskTreeNode root) { 
    93         return new TaskTree(root); 
     93    public ITaskInstance createNewTaskInstance(ITask task) { 
     94        return new TaskInstance(task); 
     95    } 
     96 
     97    /* (non-Javadoc) 
     98     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory#createNewTaskInstanceList() 
     99     */ 
     100    @Override 
     101    public ITaskInstanceList createNewTaskInstanceList() { 
     102        return new TaskInstance(new Sequence()); 
     103    } 
     104 
     105    /* (non-Javadoc) 
     106     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory#createUserSession() 
     107     */ 
     108    @Override 
     109    public IUserSession createUserSession() { 
     110        return new UserSession(); 
     111    } 
     112 
     113    /* (non-Javadoc) 
     114     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory#createTaskModel(IUserSession) 
     115     */ 
     116    @Override 
     117    public ITaskModel createTaskModel(List<IUserSession> userSessions) { 
     118        return new TaskModel(userSessions); 
    94119    } 
    95120 

  • trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskModel.java

    r1132 r1146  
    1515package de.ugoe.cs.autoquest.tasktrees.treeimpl; 
    1616 
     17import java.util.Collection; 
     18import java.util.Collections; 
    1719import java.util.HashMap; 
     20import java.util.List; 
    1821import java.util.Map; 
    1922 
    20 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; 
    21 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
    22 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeInfo; 
     23import de.ugoe.cs.autoquest.tasktrees.treeifc.IMarkingTemporalRelationship; 
     24import de.ugoe.cs.autoquest.tasktrees.treeifc.IStructuringTemporalRelationship; 
     25import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
     26import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
     27import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
     28import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInfo; 
     29import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession; 
    2330 
    2431/** 
    … …  
    2835 * @author 2012, last modified by $Author: patrick$ 
    2936 */ 
    30 public class TaskTree implements ITaskTree { 
     37class TaskModel implements ITaskModel { 
    3138     
    32     /** the map of nodes */ 
    33     private Map<ITaskTreeNode, ITaskTreeNodeInfo> taskMap; 
     39    /** */ 
     40    private static final long serialVersionUID = 1L; 
    3441 
    35     /** the root node of the task tree */ 
    36     private ITaskTreeNode rootNode; 
     42    /** the map of tasks */ 
     43    private List<IUserSession> userSessions; 
     44 
     45    /** the map of tasks */ 
     46    private Map<ITask, TaskInfo> taskMap = new HashMap<ITask, TaskInfo>(); 
    3747 
    3848    /** 
    39      * TODO: comment 
    40      *  
     49     * 
    4150     */ 
    42     TaskTree(ITaskTreeNode rootNode) { 
    43         this.rootNode = rootNode; 
     51    TaskModel(List<IUserSession> userSessions) { 
     52        if ((userSessions == null) || (userSessions.size() == 0)) { 
     53            throw new IllegalArgumentException("user sessions must not be null"); 
     54        } 
     55         
     56        this.userSessions = userSessions; 
     57         
     58        for (IUserSession session : this.userSessions) { 
     59            for (ITaskInstance taskInstance : session) { 
     60                addTaskToMap(taskInstance.getTask()); 
     61            } 
     62        } 
    4463    } 
    4564 
    46     /* 
    47      * (non-Javadoc) 
    48      *  
    49      * @see de.ugoe.cs.tasktree.treeifc.TaskTree#getRoot() 
     65 
     66    /* (non-Javadoc) 
     67     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel#getUserSessions() 
    5068     */ 
    5169    @Override 
    52     public ITaskTreeNode getRoot() { 
    53         return rootNode; 
     70    public List<IUserSession> getUserSessions() { 
     71        return Collections.unmodifiableList(userSessions); 
    5472    } 
    5573 
    56     /* 
    57      * (non-Javadoc) 
    58      *  
    59      * @see de.ugoe.cs.tasktree.treeifc.TaskTree#getTaskMap() 
     74 
     75    /* (non-Javadoc) 
     76     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel#getTasks() 
    6077     */ 
    6178    @Override 
    62     public synchronized Map<ITaskTreeNode, ITaskTreeNodeInfo> getTaskMap() { 
    63         if (taskMap == null) { 
    64             taskMap = new HashMap<ITaskTreeNode, ITaskTreeNodeInfo>(); 
    65             addNodeToMap(rootNode, null); 
    66         } 
    67         return taskMap; 
     79    public Collection<ITask> getTasks() { 
     80        return Collections.unmodifiableCollection(taskMap.keySet()); 
     81    } 
     82 
     83 
     84    /* (non-Javadoc) 
     85     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel#getTaskInfo(de.ugoe.cs.autoquest.tasktrees.treeifc.ITask) 
     86     */ 
     87    @Override 
     88    public ITaskInfo getTaskInfo(ITask task) { 
     89        return taskMap.get(task); 
    6890    } 
    6991 
    7092    /** 
    71      * TODO: comment 
    72      *  
    73      * @param rootNode 
     93     * 
    7494     */ 
    75     private void addNodeToMap(ITaskTreeNode node, ITaskTreeNode parent) { 
    76         NodeInfo nodeInfo = (NodeInfo) taskMap.get(node); 
     95    private void addTaskToMap(ITask task) { 
     96        TaskInfo taskInfo = taskMap.get(task); 
    7797 
    78         if (nodeInfo == null) { 
    79             nodeInfo = new NodeInfo(node); 
    80             taskMap.put(node, nodeInfo); 
     98        if (taskInfo == null) { 
     99            taskInfo = new TaskInfo(task); 
     100            taskMap.put(task, taskInfo); 
    81101        } 
    82102 
    83         if (parent != null) { 
    84             // through first removing an existing parent it is assured, that a parent is recorded 
    85             // only once. This is needed, because parent may be reused in a tree as well, but we 
    86             // always iterate the whole tree 
    87             //nodeInfo.removeParent(parent); 
    88             nodeInfo.addParent(parent); 
     103        if (task instanceof IStructuringTemporalRelationship) { 
     104            for (ITask child : ((IStructuringTemporalRelationship) task).getChildren()) { 
     105                addTaskToMap(child); 
     106            } 
    89107        } 
    90  
    91         for (ITaskTreeNode child : node.getChildren()) { 
    92             addNodeToMap(child, node); 
     108        else if (task instanceof IMarkingTemporalRelationship) { 
     109            addTaskToMap(((IMarkingTemporalRelationship) task).getMarkedTask()); 
    93110        } 
    94111    } 
    … …  
    100117     */ 
    101118    @Override 
    102     public TaskTree clone() { 
    103         TaskTree clone = null; 
    104         try { 
    105             clone = (TaskTree) super.clone(); 
    106  
    107             clone.rootNode = rootNode.clone(); 
    108  
    109             // the clone will create the task map itself, when it is first retrieved 
    110             clone.taskMap = null; 
    111  
    112         } 
    113         catch (CloneNotSupportedException e) { 
    114             // this should never happen. Therefore simply dump the exception 
    115             e.printStackTrace(); 
    116         } 
    117  
    118         return clone; 
     119    public TaskModel clone() { 
     120        return new TaskModel(userSessions); 
    119121    } 
    120122 
Note: See TracChangeset for help on using the changeset viewer.