// Copyright 2012 Georg-August-Universität Göttingen, Germany // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package de.ugoe.cs.autoquest.plugin.html; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStreamReader; import java.io.UnsupportedEncodingException; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; import javax.xml.parsers.ParserConfigurationException; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import org.xml.sax.Attributes; import org.xml.sax.InputSource; import org.xml.sax.Locator; import org.xml.sax.SAXException; import org.xml.sax.SAXParseException; import org.xml.sax.helpers.DefaultHandler; import de.ugoe.cs.autoquest.eventcore.Event; import de.ugoe.cs.autoquest.eventcore.guimodel.GUIElementTree; import de.ugoe.cs.autoquest.eventcore.guimodel.GUIModel; import de.ugoe.cs.util.console.Console; /** *
* This class provides the functionality to parse XML log files generated monitors of * AutoQUEST. The result of parsing a file is a collection of event sequences and a GUI model. * This class must be extended by implementing a subclass and the abstract method to complete * the implementation. *
* * @author Patrick Harms * @version 1.0 * */ public abstract class AbstractDefaultLogParser extends DefaultHandler { /** ** Collection of event sequences that is contained in the parsed log file. *
*/ private Collection* Internal handle to the parsed GUI structure, stored in a GUIElementTree *
*/ private GUIElementTree* Id of the GUI element currently being parsed. *
*/ private String currentGUIElementId; /** ** the buffer for GUI elements already parsed but not processed yet (because e.g. the parent * GUI element has not been parsed yet) *
*/ private List* Internal handle to type of the event currently being parsed. *
*/ private String currentEventType; /** ** the buffer for events already parsed but not processed yet (because e.g. the target * GUI element has not been parsed yet) *
*/ private List* Internal handle to the parameters of the event currently being entity. *
*/ private Map* Internal handle to the sequence currently being parsed. *
*/ private List* the handle to the locator for correctly throwing exceptions with location information *
*/ private Locator locator; /** ** Constructor. Creates a new logParser. *
*/ public AbstractDefaultLogParser() { sequences = new LinkedList* Parses a log file written by the HTMLMonitor and creates a collection of event sequences. *
* * @param filename * name and path of the log file * * @throws SAXException in the case, the file could not be parsed */ public void parseFile(String filename) throws SAXException { if (filename == null) { throw new IllegalArgumentException("filename must not be null"); } parseFile(new File(filename)); } /** ** Parses a log file written by the HTMLMonitor and creates a collection of event sequences. *
* * @param file * file to be parsed * * @throws SAXException in the case, the file could not be parsed */ public void parseFile(File file) throws SAXException { if (file == null) { throw new IllegalArgumentException("file must not be null"); } SAXParserFactory spf = SAXParserFactory.newInstance(); spf.setValidating(true); SAXParser saxParser = null; InputSource inputSource = null; try { saxParser = spf.newSAXParser(); inputSource = new InputSource(new InputStreamReader(new FileInputStream(file), "UTF-8")); } catch (UnsupportedEncodingException e) { Console.printerrln("Error parsing file " + file.getName()); Console.logException(e); throw new SAXParseException("Error parsing file " + file.getName(), locator, e); } catch (ParserConfigurationException e) { Console.printerrln("Error parsing file " + file.getName()); Console.logException(e); throw new SAXParseException("Error parsing file " + file.getName(), locator, e); } catch (FileNotFoundException e) { Console.printerrln("Error parsing file " + file.getName()); Console.logException(e); throw new SAXParseException("Error parsing file " + file.getName(), locator, e); } // we parse a new file. So clear the buffers. guiElementBuffer.clear(); eventBuffer.clear(); if (inputSource != null) { inputSource.setSystemId("file://" + file.getAbsolutePath()); try { if (saxParser == null) { throw new RuntimeException("SaxParser creation failed"); } saxParser.parse(inputSource, this); } catch (IOException e) { Console.printerrln("Error parsing file " + file.getName()); Console.logException(e); throw new SAXParseException("Error parsing file " + file.getName(), locator, e); } catch (SAXParseException e) { if ("XML document structures must start and end within the same entity.".equals (e.getMessage())) { // this only denotes, that the final session tag is missing, because the // file wasn't completed. Ignore this but complete the session eventBuffer.add(new BufferEntry("sessionSwitch", null)); processEvents(); } else { throw e; } } } if (guiElementBuffer.size() > 0) { Console.println(guiElementBuffer.size() + " GUI elements not processed"); } if (eventBuffer.size() > 0) { Console.printerrln(eventBuffer.size() + " events not processed"); } } /** ** Returns a collection of event sequences that was obtained from parsing log files. *
* * @return */ public Collection* Returns the GUI model that is obtained from parsing log files. *
* * @return GUIModel */ public GUIModel getGuiModel() { return guiElementTree.getGUIModel(); } /* (non-Javadoc) * @see org.xml.sax.helpers.DefaultHandler#setDocumentLocator(org.xml.sax.Locator) */ @Override public void setDocumentLocator(Locator locator) { this.locator = locator; } /* * (non-Javadoc) * * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String, java.lang.String, * java.lang.String, org.xml.sax.Attributes) */ @Override public void startElement(String uri, String localName, String qName, Attributes atts) throws SAXException { if (qName.equals("session")) { // do nothing } else if (qName.equals("component")) { currentGUIElementId = atts.getValue("id"); currentParameters = new HashMap* called to handle parsed GUI elements *
* * @param id the id of the parsed GUI element * @param parameters all parameters parsed for the GUI element * * @return true, if the GUI element could be handled. In this case this method is not called * again for the same GUI element. Otherwise the method is called later again. This * may be required, if a child GUI element is parsed before the parent GUI element */ protected abstract boolean handleGUIElement(String id, Map* called to handle parsed events *
* * @param type the type of the parsed event * @param parameters the parameters of the parsed event * * @return true, if the event could be handled. In this case this method is not called * again for the same event. Otherwise the method is called later again. This * may be required, if e.g. the target of the event, i.e. the GUI element, is not yet * parsed */ protected abstract boolean handleEvent(String type, Map* returns the tree of parsed GUI elements, which consists of the ids of the GUI elements *
* * @return as described */ protected GUIElementTree* adds an event to the currently parsed sequence of events *
* * @param event */ protected void addToSequence(Event event) { currentSequence.add(event); } /** ** this method internally processes GUI elements, that have been parsed but not processed yet. * I.e., for such GUI elements, either the method {@link #handleGUIElement(String, Map)} has * not been called yet, or it returned false for the previous calls. In this case, the method * is called (again). Furthermore, the processing of events is initiated by a call to * {@link #processEvents()}. *
*/ private void processGUIElements() throws SAXException { int processedElements = 0; boolean processedElement; do { processedElement = false; // search for the next GUI element that can be processed (use an iterator on the // linked list, as this is most effective) Iterator* this method internally processes events, that have been parsed but not processed yet. * I.e., for such events, either the method {@link #handleEvent(String, Map)} has * not been called yet, or it returned false for the previous calls. In this case, the method * is called (again). *
*/ private void processEvents() throws SAXException { boolean processedEvent; do { processedEvent = false; // check, if the next event can be processed if (eventBuffer.size() > 0) { BufferEntry entry = eventBuffer.get(0); if ((entry != null) && (entry.id != null) && (entry.parameters != null)) { processedEvent = handleEvent(entry.id, entry.parameters); if (processedEvent) { eventBuffer.remove(0); } } else { // the entry signals a session switch. Close the current session and start the // next one if (currentSequence.size() > 0) { sequences.add(currentSequence); currentSequence = new LinkedList* This class is used internally for storing events and GUI elements in lists. *
*/ private static class BufferEntry { /** */ private String id; /** */ private Map