Ignore:
Timestamp:
09/09/11 06:23:36 (13 years ago)
Author:
sherbold
Message:
  • code documentation and formatting
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/SequenceSplitter.java

    r77 r171  
    44import java.util.List; 
    55 
     6import de.ugoe.cs.eventbench.data.Event; 
    67import de.ugoe.cs.eventbench.windows.data.WindowsMessage; 
    78import de.ugoe.cs.util.console.Console; 
    89 
     10/** 
     11 * <p> 
     12 * Responsible to split sequences into subsequences, such that each subsequences 
     13 * contains exactly one event. 
     14 * </p> 
     15 *  
     16 * @author Steffen Herbold 
     17 * @version 1.0 
     18 */ 
    919public class SequenceSplitter { 
    1020 
     21        /** 
     22         * <p> 
     23         * Contains the current subsequence. 
     24         * </p> 
     25         */ 
    1126        private List<WindowsMessage> currentSequence; 
    12          
     27 
     28        /** 
     29         * <p> 
     30         * Number of messages in the current sequences, that signal that a key or 
     31         * mouse button has been pressed down to which not yet a message has been 
     32         * found, that signals that the button has been released. 
     33         * </p> 
     34         */ 
    1335        private int openDowns; 
    14          
     36 
     37        /** 
     38         * <p> 
     39         * Internal flag that signals if {@link #currentSequence} needs to be 
     40         * initialized. 
     41         * </p> 
     42         */ 
    1543        private boolean initMessages; 
    16          
     44 
     45        /** 
     46         * <p> 
     47         * The {@link EventGenerator} used to convert the subsequences into 
     48         * {@link Event}s 
     49         * </p> 
     50         */ 
    1751        private EventGenerator tokenGenerator; 
    18          
     52 
     53        /** 
     54         * <p> 
     55         * The event sequence generated. 
     56         * </p> 
     57         */ 
    1958        private List<WindowsEvent> actionSequence; 
    20          
     59 
     60        /** 
     61         * <p> 
     62         * Constructor. Creates a new SequenceSplitter. 
     63         * </p> 
     64         */ 
    2165        public SequenceSplitter() { 
    2266                currentSequence = new LinkedList<WindowsMessage>(); 
    … …  
    2670                actionSequence = new LinkedList<WindowsEvent>(); 
    2771        } 
    28          
     72 
     73        /** 
     74         * <p> 
     75         * Called by the {@link LogParser} every time a message is parsed. 
     76         * </p> 
     77         *  
     78         * @param msg 
     79         *            message to be added 
     80         */ 
    2981        public void addMessage(WindowsMessage msg) { 
    30                 if( startOfSequence(msg) ) { 
    31                         if( !initMessages ) { 
    32                                 WindowsEvent currentAction = tokenGenerator.generateEvent(currentSequence); 
    33                                 if( currentAction!=null ) { 
     82                if (startOfSequence(msg)) { 
     83                        if (!initMessages) { 
     84                                WindowsEvent currentAction = tokenGenerator 
     85                                                .generateEvent(currentSequence); 
     86                                if (currentAction != null) { 
    3487                                        actionSequence.add(currentAction); 
    3588                                } 
    36                                 if( isKeyMessage(msg.getType()) && openDowns>0 ) { 
     89                                if (isKeyMessage(msg.getType()) && openDowns > 0) { 
    3790                                        Console.traceln("Key message found with open down mouse messages - will probabably result in a faulty sequence."); 
    3891                                } 
    … …  
    4194                        } 
    4295                        currentSequence = new LinkedList<WindowsMessage>(); 
    43                 }  
    44                 if( isUpMessage(msg.getType()) ) { 
    45                         if( openDowns>0 ) {  
     96                } 
     97                if (isUpMessage(msg.getType())) { 
     98                        if (openDowns > 0) { 
    4699                                openDowns--; 
    47100                        } 
    … …  
    49102                currentSequence.add(msg); 
    50103        } 
    51          
     104 
     105        /** 
     106         * <p> 
     107         * Returns the event sequence generated from the message that have been 
     108         * added. 
     109         * </p> 
     110         *  
     111         * @return generated event sequence 
     112         */ 
    52113        public List<WindowsEvent> getSequence() { 
    53114                return actionSequence; 
    54115        } 
    55          
     116 
     117        /** 
     118         * <p> 
     119         * Called when a session in the log file is finished, i.e., a closing 
     120         * session-node is found. 
     121         * </p> 
     122         */ 
    56123        public void endSession() { 
    57                 WindowsEvent currentAction = tokenGenerator.generateEvent(currentSequence); 
    58                 if( currentAction!=null ) { 
     124                WindowsEvent currentAction = tokenGenerator 
     125                                .generateEvent(currentSequence); 
     126                if (currentAction != null) { 
    59127                        actionSequence.add(currentAction); 
    60128                } 
    61129        } 
    62130 
     131        /** 
     132         * <p> 
     133         * Checks if the message starts a new subsequence and returns the result. 
     134         * </p> 
     135         *  
     136         * @param msg 
     137         *            message that is checked 
     138         * @return true, if a new subsequence begins 
     139         */ 
    63140        private boolean startOfSequence(WindowsMessage msg) { 
    64141                boolean isStart = false; 
    65142                int msgType = msg.getType(); 
    66                 if( isKeyMessage(msgType) ) { 
     143                if (isKeyMessage(msgType)) { 
    67144                        isStart = true; 
    68145                } 
    69                 if( isDownMessage(msgType) ) { 
     146                if (isDownMessage(msgType)) { 
    70147                        openDowns++; 
    71                         if( openDowns==1 ) { 
     148                        if (openDowns == 1) { 
    72149                                isStart = true; 
    73150                        } 
    74151                } 
    75                 if( isDblclkMessage(msgType) ) { 
     152                if (isDblclkMessage(msgType)) { 
    76153                        openDowns++; 
    77154                } 
    … …  
    79156        } 
    80157 
     158        /** 
     159         * <p> 
     160         * Checks if the type of a message is generated is a keyboard interaction. 
     161         * </p> 
     162         *  
     163         * @param msgType 
     164         *            type of the message 
     165         * @return true if it is a keyboard interaction; false otherwise 
     166         */ 
    81167        private boolean isKeyMessage(int msgType) { 
    82168                boolean isKeyMsg = false; 
    83169                switch (msgType) { 
    84                         case MessageDefs.WM_KEYDOWN: 
    85                         case MessageDefs.WM_KEYUP: 
    86                         case MessageDefs.WM_SYSKEYDOWN: 
    87                         case MessageDefs.WM_SYSKEYUP: 
    88                                 isKeyMsg = true; 
    89                                 break; 
    90                         default: 
    91                                         break; 
     170                case MessageDefs.WM_KEYDOWN: 
     171                case MessageDefs.WM_KEYUP: 
     172                case MessageDefs.WM_SYSKEYDOWN: 
     173                case MessageDefs.WM_SYSKEYUP: 
     174                        isKeyMsg = true; 
     175                        break; 
     176                default: 
     177                        break; 
    92178                } 
    93179                return isKeyMsg; 
    94180        } 
    95          
     181 
     182        /** 
     183         * <p> 
     184         * Checks if the type of a message indicates that the mouse has been pressed 
     185         * down. 
     186         * </p> 
     187         *  
     188         * @param msgType 
     189         *            type of the message 
     190         * @return true if it is mouse-down message; false otherwise 
     191         */ 
    96192        private boolean isDownMessage(int msgType) { 
    97193                boolean isDownMsg = false; 
    98194                switch (msgType) { 
    99                         case MessageDefs.WM_LBUTTONDOWN: 
    100                         case MessageDefs.WM_RBUTTONDOWN: 
    101                         case MessageDefs.WM_MBUTTONDOWN: 
    102                         case MessageDefs.WM_XBUTTONDOWN: 
    103                         case MessageDefs.WM_NCLBUTTONDOWN: 
    104                         case MessageDefs.WM_NCRBUTTONDOWN: 
    105                         case MessageDefs.WM_NCMBUTTONDOWN: 
    106                         case MessageDefs.WM_NCXBUTTONDOWN: 
    107                                 isDownMsg = true; 
    108                                 break; 
    109                         default: 
    110                                 break; 
     195                case MessageDefs.WM_LBUTTONDOWN: 
     196                case MessageDefs.WM_RBUTTONDOWN: 
     197                case MessageDefs.WM_MBUTTONDOWN: 
     198                case MessageDefs.WM_XBUTTONDOWN: 
     199                case MessageDefs.WM_NCLBUTTONDOWN: 
     200                case MessageDefs.WM_NCRBUTTONDOWN: 
     201                case MessageDefs.WM_NCMBUTTONDOWN: 
     202                case MessageDefs.WM_NCXBUTTONDOWN: 
     203                        isDownMsg = true; 
     204                        break; 
     205                default: 
     206                        break; 
    111207                } 
    112208                return isDownMsg; 
    113209        } 
    114210 
     211        /** 
     212         * <p> 
     213         * Checks if the type of a message indicates that a double click has been 
     214         * performed. 
     215         * </p> 
     216         *  
     217         * @param msgType 
     218         *            type of the message 
     219         * @return true if it is a double click message; false otherwise 
     220         */ 
    115221        private boolean isDblclkMessage(int msgType) { 
    116222                boolean isDblclkMsg = false; 
    117223                switch (msgType) { 
    118                         case MessageDefs.WM_LBUTTONDBLCLK: 
    119                         case MessageDefs.WM_RBUTTONDBLCLK: 
    120                         case MessageDefs.WM_MBUTTONDBLCLK: 
    121                         case MessageDefs.WM_XBUTTONDBLCLK: 
    122                         case MessageDefs.WM_NCLBUTTONDBLCLK: 
    123                         case MessageDefs.WM_NCRBUTTONDBLCLK: 
    124                         case MessageDefs.WM_NCMBUTTONDBLCLK: 
    125                         case MessageDefs.WM_NCXBUTTONDBLCLK: 
    126                                 isDblclkMsg = true; 
    127                                 break; 
    128                         default: 
    129                                 break; 
     224                case MessageDefs.WM_LBUTTONDBLCLK: 
     225                case MessageDefs.WM_RBUTTONDBLCLK: 
     226                case MessageDefs.WM_MBUTTONDBLCLK: 
     227                case MessageDefs.WM_XBUTTONDBLCLK: 
     228                case MessageDefs.WM_NCLBUTTONDBLCLK: 
     229                case MessageDefs.WM_NCRBUTTONDBLCLK: 
     230                case MessageDefs.WM_NCMBUTTONDBLCLK: 
     231                case MessageDefs.WM_NCXBUTTONDBLCLK: 
     232                        isDblclkMsg = true; 
     233                        break; 
     234                default: 
     235                        break; 
    130236                } 
    131237                return isDblclkMsg; 
    132238        } 
    133          
     239 
     240        /** 
     241         * <p> 
     242         * Checks if the type of a message indicates that the mouse has been 
     243         * released. 
     244         * </p> 
     245         *  
     246         * @param msgType 
     247         *            type of the message 
     248         * @return true if it is mouse-up message; false otherwise 
     249         */ 
    134250        private boolean isUpMessage(int msgType) { 
    135251                boolean isUpMsg = false; 
    136252                switch (msgType) { 
    137                         case MessageDefs.WM_LBUTTONUP: 
    138                         case MessageDefs.WM_RBUTTONUP: 
    139                         case MessageDefs.WM_MBUTTONUP: 
    140                         case MessageDefs.WM_XBUTTONUP: 
    141                         case MessageDefs.WM_NCLBUTTONUP: 
    142                         case MessageDefs.WM_NCRBUTTONUP: 
    143                         case MessageDefs.WM_NCMBUTTONUP: 
    144                         case MessageDefs.WM_NCXBUTTONUP: 
    145                                 isUpMsg = true; 
    146                                 break; 
    147                         default: 
    148                                 break; 
     253                case MessageDefs.WM_LBUTTONUP: 
     254                case MessageDefs.WM_RBUTTONUP: 
     255                case MessageDefs.WM_MBUTTONUP: 
     256                case MessageDefs.WM_XBUTTONUP: 
     257                case MessageDefs.WM_NCLBUTTONUP: 
     258                case MessageDefs.WM_NCRBUTTONUP: 
     259                case MessageDefs.WM_NCMBUTTONUP: 
     260                case MessageDefs.WM_NCXBUTTONUP: 
     261                        isUpMsg = true; 
     262                        break; 
     263                default: 
     264                        break; 
    149265                } 
    150266                return isUpMsg; 
    151267        } 
    152          
     268 
    153269} 
Note: See TracChangeset for help on using the changeset viewer.