Changeset 2165

Timestamp:

09/07/17 16:19:49 (7 years ago)

Author:

pharms

Message:

• changes for first VR oriented usability evaluation

Location:

trunk/autoquest-plugin-genericevents/src/main/java/de/ugoe/cs/autoquest/plugin/genericevents

Files:

• GenericEventLogParser.java (modified) (6 diffs)
• GenericEventLogSplitter.java (added)
• commands/CMDparseDirGenericEvents.java (modified) (6 diffs)
• commands/CMDparseGenericEvents.java (added)
• commands/CMDsplitDirGenericEvents.java (added)

trunk/autoquest-plugin-genericevents/src/main/java/de/ugoe/cs/autoquest/plugin/genericevents/GenericEventLogParser.java

@@ -15 +15 @@
 package de.ugoe.cs.autoquest.plugin.genericevents;
 
+import java.time.Duration;
+import java.util.GregorianCalendar;
 import java.util.Map;
+import java.util.Set;
 
 import org.xml.sax.SAXException;
@@ -39 +42 @@
 public class GenericEventLogParser extends AbstractDefaultLogParser {
     
+    /** types of events to be ignored */
+    private Set<String> ignoredEvents;
+    
+    
+    /**
+     * <p>
+     * used to provide the parser with a set of ignored event types.
+     * </p>
+     *
+     * @param ignoredEvents
+     */
+    public GenericEventLogParser(Set<String> ignoredEvents) {
+        super();
+        this.ignoredEvents = ignoredEvents;
+    }
+
     /* (non-Javadoc)
      * @see de.ugoe.cs.autoquest.plugin.html.AbstractDefaultLogParser#handleGUIElement(String, Map)
@@ -47 +66 @@
     {
         String parentId = parameters.get("parent");
+        
+        if (parentId != null) {
+            // check, if the parent is already in the tree
+            if (super.getTargetTree().find(parentId) == null) {
+                // element cannot yet be processed as parent is not existing yet
+                return false;
+            }
+        }
         
         GenericEventTargetSpec specification = new GenericEventTargetSpec(id, parameters);
@@ -66 +93 @@
     @Override
     protected boolean handleEvent(String type, Map<String, String> parameters) throws SAXException {
+        // ignore the event based on its type if requested
+        if (ignoredEvents.contains(type)) {
+            return true;
+        }
+        
         String targetId = parameters.get("targetId");
+        
+        // ignore the event based on type and target id if requested
+        if (ignoredEvents.contains(type + "." + targetId)) {
+            return true;
+        }
         
         if (targetId == null) {
@@ -82 +119 @@
         
             if (timestampStr != null) {
-                event.setTimestamp(Long.parseLong(timestampStr));
+                event.setTimestamp(determineTimestamp(timestampStr));
+            }
+            
+            for (Map.Entry<String, String> parameter : parameters.entrySet()) {
+                if (!"targetId".equals(parameter.getKey()) &&
+                    !"timestamp".equals(parameter.getKey()))
+                {
+                    event.setParameter(parameter.getKey(), parameter.getValue());
+                }
             }
         
@@ -92 +137 @@
     }
 
+    /**
+     * convenience method to align different timestamp formats
+     */
+    private long determineTimestamp(String timestampStr) {
+        long val = Long.parseLong(timestampStr);
+        
+        // We expect any recording to have taken place in years with at most 4 digits. Hence,
+        // divide the val until we reach such a year
+        long max = new GregorianCalendar(10000, 1, 1).getTimeInMillis();
+        
+        while (max < val) {
+            val /= 10; 
+        }
+        
+        // now, it can still be the case, that the base line is wrong. I.e., the remaining value
+        // may be milliseconds, but not starting from 1970, as we expect it, but starting from
+        // year 1 of the gregorian calendar. If this is the case, the date is still in the future.
+        // Hence, we substract the milliseconds between year 1 of the gregorian calendar and 1970.
+        // (We took these magic number, as they provide correct results. It's not fully clear,
+        //  why the January 1st 1970 does not work correctly but provides an offset of two days)
+        if (val > System.currentTimeMillis()) {
+            Duration duration = Duration.between(new GregorianCalendar(1, 1, 1).toInstant(),
+                                                 new GregorianCalendar(1969, 12, 30).toInstant());
+            
+            val -= duration.toMillis();
+        }
+        
+        return val;
+    }
+
 }

trunk/autoquest-plugin-genericevents/src/main/java/de/ugoe/cs/autoquest/plugin/genericevents/commands/CMDparseDirGenericEvents.java

@@ -18 +18 @@
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.logging.Level;
 
@@ -50 +52 @@
         String path = null;
         String sequencesName = null;
-
+        
+        Set<String> ignoredEvents = new HashSet<>();
+        
         try {
             for (int i = 0; i < parameters.size(); i++) {
@@ -59 +63 @@
                 else if (sequencesName == null) {
                     sequencesName = param;
+                }
+                else {
+                    ignoredEvents.add(param);
                 }
             }
@@ -76 +83 @@
         }
 
-        GenericEventLogParser parser = new GenericEventLogParser();
+        GenericEventLogParser parser = new GenericEventLogParser(ignoredEvents);
 
         parseFile(folder, parser);
@@ -121 +128 @@
             catch (Exception e) {
                 Console.printerrln("Could not parse " + source + ": " + e.getMessage());
+                e.printStackTrace();
             }
         }
@@ -132 +140 @@
     @Override
     public String help() {
-        return "parseDirGenericEvents <directory> [<sequencesName>]";
+        return "parseDirGenericEvents <directory> [<sequencesName>] [<ignoredEventType>*] [<ignoredEventType.ignoredEventTargetId>*]";
     }