XmlDataHandler.java

  1. /*******************************************************************************
  2.  * Copyright 2012 André Rouél
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  *   http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  ******************************************************************************/
  16. package net.sf.uadetector.internal.data;

  18. import java.io.IOException;
  19. import java.io.InputStream;
  20. import java.io.InputStreamReader;

  22. import javax.annotation.Nonnull;

  24. import net.sf.qualitycheck.Check;
  25. import net.sf.uadetector.internal.data.domain.Browser;
  26. import net.sf.uadetector.internal.data.domain.BrowserOperatingSystemMapping;
  27. import net.sf.uadetector.internal.data.domain.BrowserPattern;
  28. import net.sf.uadetector.internal.data.domain.BrowserType;
  29. import net.sf.uadetector.internal.data.domain.Device;
  30. import net.sf.uadetector.internal.data.domain.DevicePattern;
  31. import net.sf.uadetector.internal.data.domain.OperatingSystem;
  32. import net.sf.uadetector.internal.data.domain.OperatingSystemPattern;
  33. import net.sf.uadetector.internal.data.domain.Robot;

  35. import org.slf4j.Logger;
  36. import org.slf4j.LoggerFactory;
  37. import org.xml.sax.Attributes;
  38. import org.xml.sax.InputSource;
  39. import org.xml.sax.SAXException;
  40. import org.xml.sax.SAXParseException;
  41. import org.xml.sax.helpers.DefaultHandler;

  43. public final class XmlDataHandler extends DefaultHandler {

  45.     public enum Tag {

  47.         /**
  48.          * Tag name of a browser entry
  49.          */
  50.         BROWSER("browser"),

  52.         /**
  53.          * Tag name of the ID of an browser pattern
  54.          */
  55.         BROWSER_ID("browser_id"),

  57.         /**
  58.          * Tag name of the informational URL of a browser entry
  59.          */
  60.         BROWSER_INFO_URL("browser_info_url"),

  62.         /**
  63.          * Tag name of a mapping entry between a browser and an operating system
  64.          */
  65.         BROWSER_OS_MAPPING("browser_os"),

  67.         /**
  68.          * Tag name of a browser pattern
  69.          */
  70.         BROWSER_PATTERN("browser_reg"),

  72.         /**
  73.          * Tag name of a browser type entry
  74.          */
  75.         BROWSER_TYPE("browser_type"),

  77.         /**
  78.          * Tag name of the type ID of a browser
  79.          */
  80.         BROWSER_TYPE_ID("type"),

  82.         /**
  83.          * Tag name of a producer company of an user agent
  84.          */
  85.         COMPANY("company"),

  87.         /**
  88.          * Tag name of the URL of a producer company from an user agent
  89.          */
  90.         COMPANY_URL("url_company"),

  92.         /**
  93.          * Tag name of a device
  94.          */
  95.         DEVICE("device"),

  97.         /**
  98.          * Tag name of a device pattern
  99.          */
  100.         DEVICE_ID("device_id"),

  102.         /**
  103.          * Tag name of the informational URL of an device entry
  104.          */
  105.         DEVICE_INFO_URL("device_info_url"),

  107.         /**
  108.          * Tag name of a device pattern
  109.          */
  110.         DEVICE_PATTERN("device_reg"),

  112.         /**
  113.          * Tag name of all devices
  114.          */
  115.         DEVICES("devices"),

  117.         /**
  118.          * Tag name of all device patterns
  119.          */
  120.         DEVICES_PATTERN("devices_reg"),

  122.         /**
  123.          * Tag name of an family of an user agent
  124.          */
  125.         FAMILY("family"),

  127.         /**
  128.          * Tag name of the icon of an entry
  129.          */
  130.         ICON("icon"),

  132.         /**
  133.          * Tag name of an ID of an user agent
  134.          */
  135.         ID("id"),

  137.         /**
  138.          * Tag name of the product name of an user agent
  139.          */
  140.         NAME("name"),

  142.         /**
  143.          * Tag name of an operating system entry
  144.          */
  145.         OPERATING_SYSTEM("os"),

  147.         /**
  148.          * Tag name of the ID of an operating system pattern
  149.          */
  150.         OPERATING_SYSTEM_ID("os_id"),

  152.         /**
  153.          * Tag name of the informational URL of an operating system entry
  154.          */
  155.         OPERATING_SYSTEM_INFO_URL("os_info_url"),

  157.         /**
  158.          * Tag name of an operating system pattern
  159.          */
  160.         OPERATING_SYSTEM_PATTERN("operating_system_reg"),

  162.         /**
  163.          * Tag name of the order of an user agent pattern
  164.          */
  165.         PATTERN_ORDER("order"),

  167.         /**
  168.          * Tag name of the regular expression of an user agent pattern
  169.          */
  170.         PATTERN_REGEX("regstring"),

  172.         /**
  173.          * Tag name of a robot entry
  174.          */
  175.         ROBOT("robot"),

  177.         /**
  178.          * Tag name of the informational URL of a robot entry
  179.          */
  180.         ROBOT_INFO_URL("bot_info_url"),

  182.         /**
  183.          * Tag name of the product URL of an user agent
  184.          */
  185.         URL("url"),

  187.         /**
  188.          * Tag name of an user agent string of a robot entry
  189.          */
  190.         USERAGENT("useragent"),

  192.         /**
  193.          * Tag name of the data version
  194.          */
  195.         VERSION("version");

  197.         public static Tag evaluate(@Nonnull final String tagName) {
  198.             Check.notNull(tagName, "tagName");

  200.             Tag result = null;
  201.             for (final Tag tag : values()) {
  202.                 if (tag.getTagName().equalsIgnoreCase(tagName)) {
  203.                     result = tag;
  204.                     break;
  205.                 }
  206.             }
  207.             return result;
  208.         }

  210.         public static boolean isBrowserOsMappingTag(final String tagName) {
  211.             return BROWSER_OS_MAPPING.getTagName().equalsIgnoreCase(tagName);
  212.         }

  214.         public static boolean isBrowserPatternTag(final String tagName) {
  215.             return BROWSER_PATTERN.getTagName().equalsIgnoreCase(tagName);
  216.         }

  218.         public static boolean isBrowserTag(final String tagName) {
  219.             return BROWSER.getTagName().equalsIgnoreCase(tagName);
  220.         }

  222.         public static boolean isBrowserTypeTag(final String tagName) {
  223.             return BROWSER_TYPE.getTagName().equalsIgnoreCase(tagName);
  224.         }

  226.         public static boolean isDevicePatternTag(final String tagName) {
  227.             return DEVICE_PATTERN.getTagName().equalsIgnoreCase(tagName);
  228.         }

  230.         public static boolean isDeviceTag(final String tagName) {
  231.             return DEVICE.getTagName().equalsIgnoreCase(tagName);
  232.         }

  234.         public static boolean isIdTag(final String tagName) {
  235.             return ID.getTagName().equalsIgnoreCase(tagName);
  236.         }

  238.         public static boolean isOperatingSystemPatternTag(final String tagName) {
  239.             return OPERATING_SYSTEM_PATTERN.getTagName().equalsIgnoreCase(tagName);
  240.         }

  242.         public static boolean isOperatingSystemTag(final String tagName) {
  243.             return OPERATING_SYSTEM.getTagName().equalsIgnoreCase(tagName);
  244.         }

  246.         public static boolean isRobotTag(final String tagName) {
  247.             return ROBOT.getTagName().equalsIgnoreCase(tagName);
  248.         }

  250.         @Nonnull
  251.         private String tagName;

  253.         private Tag(@Nonnull final String tagName) {
  254.             this.tagName = tagName;
  255.         }

  257.         @Nonnull
  258.         public String getTagName() {
  259.             return tagName;
  260.         }

  262.     }

  264.     /**
  265.      * Character set to read the internal Document Type Definition (DTD) of UAS data
  266.      */
  267.     private static final String CHARSET = "UTF-8";

  269.     /**
  270.      * Corresponding logger for this class
  271.      */
  272.     private static final Logger LOG = LoggerFactory.getLogger(XmlDataHandler.class);

  274.     /**
  275.      * Path to the internal Document Type Definition (DTD) of UAS data files to be able to work completely offline
  276.      */
  277.     protected static final String UASDATA_DEF = "uadetector/uasxmldata.dtd";

  279.     /**
  280.      * URL to the Document Type Definition (DTD) of UAS data files
  281.      */
  282.     protected static final String UASDATA_DEF_URL = "http://user-agent-string.info/rpc/uasxmldata.dtd";

  284.     /**
  285.      * Logs an issue while parsing XML.
  286.      * 
  287.      * @param prefix
  288.      *            log level as string to add at the beginning of the message
  289.      * @param e
  290.      *            exception to log
  291.      */
  292.     protected static void logParsingIssue(final String prefix, final SAXParseException e) {
  293.         final StringBuilder buffer = new StringBuilder();
  294.         buffer.append(prefix);
  295.         buffer.append(" while reading UAS data: ");
  296.         buffer.append(e.getMessage());
  297.         buffer.append(" (line: ");
  298.         buffer.append(e.getLineNumber());
  299.         if (e.getSystemId() != null) {
  300.             buffer.append(" uri: ");
  301.             buffer.append(e.getSystemId());
  302.         }
  303.         buffer.append(")");
  304.         LOG.warn(buffer.toString());
  305.     }

  307.     private Browser.Builder browserBuilder = new Browser.Builder();

  309.     private Device.Builder deviceBuilder = new Device.Builder();

  311.     private BrowserOperatingSystemMapping.Builder browserOsMappingBuilder = new BrowserOperatingSystemMapping.Builder();

  313.     private BrowserPattern.Builder browserPatternBuilder = new BrowserPattern.Builder();

  315.     private DevicePattern.Builder devicePatternBuilder = new DevicePattern.Builder();

  317.     private BrowserType.Builder browserTypeBuilder = new BrowserType.Builder();

  319.     private StringBuilder buffer = new StringBuilder();

  321.     private Tag currentTag = null;

  323.     @Nonnull
  324.     private final DataBuilder dataBuilder;

  326.     /**
  327.      * Flag to note that a fatal error occurred while parsing the document
  328.      */
  329.     private boolean error = false;

  331.     private boolean isBrowser = false;

  333.     private boolean isBrowserOsMapping = false;

  335.     private boolean isBrowserPattern = false;

  337.     private boolean isBrowserType = false;

  339.     private boolean isDevice = false;

  341.     private boolean isDevicePattern = false;

  343.     private boolean isOperatingSystem = false;

  345.     private boolean isOperatingSystemPattern = false;

  347.     private boolean isRobot = false;

  349.     private OperatingSystem.Builder operatingSystemBuilder = new OperatingSystem.Builder();

  351.     private OperatingSystemPattern.Builder operatingSystemPatternBuilder = new OperatingSystemPattern.Builder();

  353.     private Robot.Builder robotBuilder = new Robot.Builder();

  355.     /**
  356.      * Flag to note that a warning occurred while parsing the document
  357.      */
  358.     private boolean warning = false;

  360.     public XmlDataHandler(@Nonnull final DataBuilder builder) {
  361.         Check.notNull(builder, "builder");

  363.         dataBuilder = builder;
  364.     }

  366.     private void addToBrowserBuilder() {
  367.         if (isBrowser) {
  368.             if (currentTag == Tag.ID) {
  369.                 browserBuilder.setId(buffer.toString());
  370.             } else if (currentTag == Tag.BROWSER_TYPE_ID) {
  371.                 browserBuilder.setTypeId(buffer.toString());
  372.             } else if (currentTag == Tag.NAME) {
  373.                 browserBuilder.setFamilyName(buffer.toString());
  374.             } else if (currentTag == Tag.URL) {
  375.                 browserBuilder.setUrl(buffer.toString());
  376.             } else if (currentTag == Tag.COMPANY) {
  377.                 browserBuilder.setProducer(buffer.toString());
  378.             } else if (currentTag == Tag.COMPANY_URL) {
  379.                 browserBuilder.setProducerUrl(buffer.toString());
  380.             } else if (currentTag == Tag.ICON) {
  381.                 browserBuilder.setIcon(buffer.toString());
  382.             } else if (currentTag == Tag.BROWSER_INFO_URL) {
  383.                 browserBuilder.setInfoUrl(buffer.toString());
  384.             }
  385.         }
  386.     }

  388.     private void addToBrowserOsMappingBuilder() {
  389.         if (isBrowserOsMapping && currentTag == Tag.BROWSER_ID) {
  390.             browserOsMappingBuilder.setBrowserId(buffer.toString());
  391.         } else if (isBrowserOsMapping && currentTag == Tag.OPERATING_SYSTEM_ID) {
  392.             browserOsMappingBuilder.setOperatingSystemId(buffer.toString());
  393.         }
  394.     }

  396.     private void addToBrowserPatternBuilder() {
  397.         if (isBrowserPattern && currentTag == Tag.PATTERN_ORDER) {
  398.             browserPatternBuilder.setPosition(buffer.toString());
  399.         } else if (isBrowserPattern && currentTag == Tag.BROWSER_ID) {
  400.             browserPatternBuilder.setId(buffer.toString());
  401.         } else if (isBrowserPattern && currentTag == Tag.PATTERN_REGEX) {
  402.             browserPatternBuilder.setPerlRegularExpression(buffer.toString());
  403.         }
  404.     }

  406.     private void addToBrowserTypeBuilder() {
  407.         if (isBrowserType && currentTag == Tag.ID) {
  408.             browserTypeBuilder.setId(buffer.toString());
  409.         } else if (isBrowserType && currentTag == Tag.BROWSER_TYPE_ID) {
  410.             browserTypeBuilder.setName(buffer.toString());
  411.         }
  412.     }

  414.     private void addToDeviceBuilder() {
  415.         if (isDevice) {
  416.             if (currentTag == Tag.ID) {
  417.                 deviceBuilder.setId(buffer.toString());
  418.             } else if (currentTag == Tag.NAME) {
  419.                 deviceBuilder.setName(buffer.toString());
  420.             } else if (currentTag == Tag.ICON) {
  421.                 deviceBuilder.setIcon(buffer.toString());
  422.             } else if (currentTag == Tag.DEVICE_INFO_URL) {
  423.                 deviceBuilder.setInfoUrl(buffer.toString());
  424.             }
  425.         }
  426.     }

  428.     private void addToDevicePatternBuilder() {
  429.         if (isDevicePattern && currentTag == Tag.PATTERN_ORDER) {
  430.             devicePatternBuilder.setPosition(buffer.toString());
  431.         } else if (isDevicePattern && currentTag == Tag.DEVICE_ID) {
  432.             devicePatternBuilder.setId(buffer.toString());
  433.         } else if (isDevicePattern && currentTag == Tag.PATTERN_REGEX) {
  434.             devicePatternBuilder.setPerlRegularExpression(buffer.toString());
  435.         }
  436.     }

  438.     private void addToOperatingSystemBuilder() {
  439.         if (isOperatingSystem) {
  440.             if (currentTag == Tag.ID) {
  441.                 operatingSystemBuilder.setId(buffer.toString());
  442.             } else if (currentTag == Tag.FAMILY) {
  443.                 operatingSystemBuilder.setFamily(buffer.toString());
  444.             } else if (currentTag == Tag.NAME) {
  445.                 operatingSystemBuilder.setName(buffer.toString());
  446.             } else if (currentTag == Tag.URL) {
  447.                 operatingSystemBuilder.setUrl(buffer.toString());
  448.             } else if (currentTag == Tag.COMPANY) {
  449.                 operatingSystemBuilder.setProducer(buffer.toString());
  450.             } else if (currentTag == Tag.COMPANY_URL) {
  451.                 operatingSystemBuilder.setProducerUrl(buffer.toString());
  452.             } else if (currentTag == Tag.ICON) {
  453.                 operatingSystemBuilder.setIcon(buffer.toString());
  454.             } else if (currentTag == Tag.OPERATING_SYSTEM_INFO_URL) {
  455.                 operatingSystemBuilder.setInfoUrl(buffer.toString());
  456.             }
  457.         }
  458.     }

  460.     private void addToOperatingSystemPatternBuilder() {
  461.         if (isOperatingSystemPattern) {
  462.             if (currentTag == Tag.PATTERN_ORDER) {
  463.                 operatingSystemPatternBuilder.setPosition(buffer.toString());
  464.             } else if (currentTag == Tag.OPERATING_SYSTEM_ID) {
  465.                 operatingSystemPatternBuilder.setId(buffer.toString());
  466.             } else if (currentTag == Tag.PATTERN_REGEX) {
  467.                 operatingSystemPatternBuilder.setPerlRegularExpression(buffer.toString());
  468.             }
  469.         }
  470.     }

  472.     private void addToRobotBuilder() {
  473.         if (isRobot) {
  474.             if (currentTag == Tag.ID) {
  475.                 robotBuilder.setId(buffer.toString());
  476.             } else if (currentTag == Tag.USERAGENT) {
  477.                 robotBuilder.setUserAgentString(buffer.toString());
  478.             } else if (currentTag == Tag.FAMILY) {
  479.                 robotBuilder.setFamilyName(buffer.toString());
  480.             } else if (currentTag == Tag.NAME) {
  481.                 robotBuilder.setName(buffer.toString());
  482.             } else if (currentTag == Tag.COMPANY) {
  483.                 robotBuilder.setProducer(buffer.toString());
  484.             } else if (currentTag == Tag.COMPANY_URL) {
  485.                 robotBuilder.setProducerUrl(buffer.toString());
  486.             } else if (currentTag == Tag.ICON) {
  487.                 robotBuilder.setIcon(buffer.toString());
  488.             } else if (currentTag == Tag.ROBOT_INFO_URL) {
  489.                 robotBuilder.setInfoUrl(buffer.toString());
  490.             }
  491.         }
  492.     }

  494.     @Override
  495.     public void characters(final char ch[], final int start, final int length) throws SAXException {
  496.         buffer.append(new String(ch, start, length));
  497.     }

  499.     @Override
  500.     public void endElement(final String uri, final String localName, final String tagName) throws SAXException {

  502.         transferToSpecificBuilderAndReset();

  504.         if (Tag.isRobotTag(tagName)) {
  505.             saveAndResetRobotBuilder();
  506.             isRobot = false;
  507.         } else if (Tag.isBrowserTag(tagName)) {
  508.             saveAndResetBrowserBuilder();
  509.             isBrowser = false;
  510.         } else if (Tag.isOperatingSystemTag(tagName)) {
  511.             saveAndResetOperatingSystemBuilder();
  512.             isOperatingSystem = false;
  513.         } else if (Tag.isBrowserTypeTag(tagName)) {
  514.             saveAndResetBrowserTypeBuilder();
  515.             isBrowserType = false;
  516.         } else if (Tag.isBrowserPatternTag(tagName)) {
  517.             saveAndResetBrowserPatternBuilder();
  518.             isBrowserPattern = false;
  519.         } else if (Tag.isBrowserOsMappingTag(tagName)) {
  520.             saveAndResetBrowserOperatingSystemMapping();
  521.             isBrowserOsMapping = false;
  522.         } else if (Tag.isOperatingSystemPatternTag(tagName)) {
  523.             saveAndResetOperatingSystemPatternBuilder();
  524.             isOperatingSystemPattern = false;
  525.         } else if (Tag.isDeviceTag(tagName)) {
  526.             saveAndResetDeviceBuilder();
  527.             isDevice = false;
  528.         } else if (Tag.isDevicePatternTag(tagName)) {
  529.             saveAndResetDevicePatternBuilder();
  530.             isDevicePattern = false;
  531.         }

  533.         currentTag = null;
  534.     }

  536.     @Override
  537.     public void error(final SAXParseException e) throws SAXException {
  538.         error = true;
  539.         logParsingIssue("Error", e);
  540.         super.fatalError(e);
  541.     }

  543.     @Override
  544.     public void fatalError(final SAXParseException e) throws SAXException {
  545.         logParsingIssue("Fatal error", e);

  547.         // this call throws a SAXException
  548.         super.fatalError(e);
  549.     }

  551.     /**
  552.      * Gets the flag whether an error occurred while parsing the document.
  553.      * 
  554.      * @return {@code true} if an error occurred otherwise {@code false}
  555.      */
  556.     public boolean hasError() {
  557.         return error;
  558.     }

  560.     /**
  561.      * Gets the flag whether an warning occurred while parsing the document.
  562.      * 
  563.      * @return {@code true} if an warning occurred otherwise {@code false}
  564.      */
  565.     public boolean hasWarning() {
  566.         return warning;
  567.     }

  569.     @Override
  570.     public InputSource resolveEntity(final String publicId, final String systemId) throws IOException, SAXException {
  571.         if (UASDATA_DEF_URL.equals(systemId)) {
  572.             final InputStream stream = this.getClass().getClassLoader().getResourceAsStream(UASDATA_DEF);
  573.             return new InputSource(new InputStreamReader(stream, CHARSET));
  574.         }
  575.         throw new SAXException("unable to resolve remote entity, systemId = " + systemId);
  576.     }

  578.     private void saveAndResetBrowserBuilder() {
  579.         dataBuilder.appendBrowserBuilder(browserBuilder);
  580.         browserBuilder = new Browser.Builder();
  581.     }

  583.     private void saveAndResetBrowserOperatingSystemMapping() {
  584.         dataBuilder.appendBrowserOperatingSystemMapping(browserOsMappingBuilder.build());
  585.         browserOsMappingBuilder = new BrowserOperatingSystemMapping.Builder();
  586.     }

  588.     private void saveAndResetBrowserPatternBuilder() {
  589.         try {
  590.             dataBuilder.appendBrowserPattern(browserPatternBuilder.build());
  591.         } catch (final IllegalArgumentException e) {
  592.             LOG.warn("Can not append browser pattern: " + e.getLocalizedMessage());
  593.         }
  594.         browserPatternBuilder = new BrowserPattern.Builder();
  595.     }

  597.     private void saveAndResetBrowserTypeBuilder() {
  598.         dataBuilder.appendBrowserType(browserTypeBuilder.build());
  599.         browserTypeBuilder = new BrowserType.Builder();
  600.     }

  602.     private void saveAndResetDeviceBuilder() {
  603.         dataBuilder.appendDeviceBuilder(deviceBuilder);
  604.         deviceBuilder = new Device.Builder();
  605.     }

  607.     private void saveAndResetDevicePatternBuilder() {
  608.         try {
  609.             dataBuilder.appendDevicePattern(devicePatternBuilder.build());
  610.         } catch (final IllegalArgumentException e) {
  611.             LOG.warn("Can not append device pattern: " + e.getLocalizedMessage());
  612.         }
  613.         devicePatternBuilder = new DevicePattern.Builder();
  614.     }

  616.     private void saveAndResetOperatingSystemBuilder() {
  617.         dataBuilder.appendOperatingSystemBuilder(operatingSystemBuilder);
  618.         operatingSystemBuilder = new OperatingSystem.Builder();
  619.     }

  621.     private void saveAndResetOperatingSystemPatternBuilder() {
  622.         try {
  623.             dataBuilder.appendOperatingSystemPattern(operatingSystemPatternBuilder.build());
  624.         } catch (final IllegalArgumentException e) {
  625.             LOG.warn("Can not append OS pattern: " + e.getLocalizedMessage());
  626.         }
  627.         operatingSystemPatternBuilder = new OperatingSystemPattern.Builder();
  628.     }

  630.     private void saveAndResetRobotBuilder() {
  631.         dataBuilder.appendRobot(robotBuilder.build());
  632.         robotBuilder = new Robot.Builder();
  633.     }

  635.     @Override
  636.     public void startElement(final String uri, final String localName, final String tagName, final Attributes attributes)
  637.             throws SAXException {

  639.         if (Tag.isRobotTag(tagName)) {
  640.             isRobot = true;
  641.         } else if (Tag.isBrowserTag(tagName)) {
  642.             isBrowser = true;
  643.         } else if (Tag.isOperatingSystemTag(tagName)) {
  644.             isOperatingSystem = true;
  645.         } else if (Tag.isBrowserTypeTag(tagName)) {
  646.             isBrowserType = true;
  647.         } else if (Tag.isBrowserPatternTag(tagName)) {
  648.             isBrowserPattern = true;
  649.         } else if (Tag.isBrowserOsMappingTag(tagName)) {
  650.             isBrowserOsMapping = true;
  651.         } else if (Tag.isOperatingSystemPatternTag(tagName)) {
  652.             isOperatingSystemPattern = true;
  653.         } else if (Tag.isDeviceTag(tagName)) {
  654.             isDevice = true;
  655.         } else if (Tag.isDevicePatternTag(tagName)) {
  656.             isDevicePattern = true;
  657.         }

  659.         currentTag = Tag.evaluate(tagName);
  660.     }

  662.     /**
  663.      * Transfers all characters of a specific tag to the corresponding builder and resets the string buffer.
  664.      */
  665.     private void transferToSpecificBuilderAndReset() {

  667.         // version
  668.         if (currentTag == Tag.VERSION) {
  669.             dataBuilder.setVersion(buffer.toString());
  670.         }

  672.         // robot browser
  673.         addToRobotBuilder();

  675.         // build browser
  676.         addToBrowserBuilder();

  678.         // build operating system
  679.         addToOperatingSystemBuilder();

  681.         // build browser pattern
  682.         addToBrowserPatternBuilder();

  684.         // build browser type
  685.         addToBrowserTypeBuilder();

  687.         // build browser to operating system mapping
  688.         addToBrowserOsMappingBuilder();

  690.         // build operating system pattern
  691.         addToOperatingSystemPatternBuilder();

  693.         // build browser
  694.         addToDeviceBuilder();

  696.         // build browser pattern
  697.         addToDevicePatternBuilder();

  699.         buffer = new StringBuilder();
  700.     }

  702.     @Override
  703.     public void warning(final SAXParseException e) throws SAXException {
  704.         warning = true;
  705.         logParsingIssue("Warning", e);
  706.         super.warning(e);
  707.     }

  709. }
Created with JaCoCo 0.6.2.201302030002