DataBuilder.java

  1. /*******************************************************************************
  2.  * Copyright 2013 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.util.ArrayList;
  19. import java.util.HashMap;
  20. import java.util.HashSet;
  21. import java.util.List;
  22. import java.util.Map;
  23. import java.util.Map.Entry;
  24. import java.util.Set;
  25. import java.util.SortedMap;
  26. import java.util.SortedSet;
  27. import java.util.TreeMap;
  28. import java.util.TreeSet;

  30. import javax.annotation.Nonnull;
  31. import javax.annotation.concurrent.NotThreadSafe;

  33. import net.sf.qualitycheck.Check;
  34. import net.sf.qualitycheck.exception.IllegalStateOfArgumentException;
  35. import net.sf.uadetector.internal.data.domain.Browser;
  36. import net.sf.uadetector.internal.data.domain.BrowserOperatingSystemMapping;
  37. import net.sf.uadetector.internal.data.domain.BrowserPattern;
  38. import net.sf.uadetector.internal.data.domain.BrowserType;
  39. import net.sf.uadetector.internal.data.domain.Device;
  40. import net.sf.uadetector.internal.data.domain.DevicePattern;
  41. import net.sf.uadetector.internal.data.domain.OperatingSystem;
  42. import net.sf.uadetector.internal.data.domain.OperatingSystemPattern;
  43. import net.sf.uadetector.internal.data.domain.Robot;

  45. import org.slf4j.Logger;
  46. import org.slf4j.LoggerFactory;

  48. /**
  49.  * This class is intended to create instances of {@code Data}.
  50.  * 
  51.  * @author André Rouél
  52.  */
  53. @NotThreadSafe
  54. public class DataBuilder {

  56.     private static final Logger LOG = LoggerFactory.getLogger(DataBuilder.class);

  58.     private static void addOperatingSystemToBrowser(final Map<Integer, Browser.Builder> browserBuilders,
  59.             final Map<Integer, OperatingSystem> operatingSystems, final Map<Integer, Integer> browserOsMap) {
  60.         Browser.Builder browserBuilder;
  61.         for (final Map.Entry<Integer, Integer> entry : browserOsMap.entrySet()) {
  62.             if (browserBuilders.containsKey(entry.getKey())) {
  63.                 browserBuilder = browserBuilders.get(entry.getKey());
  64.                 if (operatingSystems.containsKey(entry.getValue())) {
  65.                     browserBuilder.setOperatingSystem(operatingSystems.get(entry.getValue()));
  66.                 } else {
  67.                     LOG.warn("Can not find an operating system with ID '" + entry.getValue() + "' for browser '"
  68.                             + browserBuilder.getProducer() + " " + browserBuilder.getFamily() + "'.");
  69.                 }
  70.             } else {
  71.                 LOG.warn("Can not find a browser with ID '" + entry.getKey() + "'.");
  72.             }
  73.         }
  74.     }

  76.     private static void addPatternToBrowser(final Map<Integer, Browser.Builder> builders,
  77.             final Map<Integer, SortedSet<BrowserPattern>> patterns) {
  78.         for (final Map.Entry<Integer, Browser.Builder> entry : builders.entrySet()) {
  79.             if (patterns.containsKey(entry.getKey())) {
  80.                 entry.getValue().setPatterns(patterns.get(entry.getKey()));
  81.             } else {
  82.                 LOG.warn("No pattern available for '" + entry.getValue().getProducer() + " " + entry.getValue().getFamily() + "'.");
  83.             }
  84.         }
  85.     }

  87.     private static void addPatternToDevice(final Map<Integer, Device.Builder> builders,
  88.             final Map<Integer, SortedSet<DevicePattern>> patterns) {
  89.         for (final Map.Entry<Integer, Device.Builder> entry : builders.entrySet()) {
  90.             if (patterns.containsKey(entry.getKey())) {
  91.                 entry.getValue().setPatterns(patterns.get(entry.getKey()));
  92.             } else {
  93.                 LOG.debug("No pattern available for '" + entry.getValue().getName() + "'.");
  94.             }
  95.         }
  96.     }

  98.     private static void addPatternToOperatingSystem(final Map<Integer, OperatingSystem.Builder> builders,
  99.             final Map<Integer, SortedSet<OperatingSystemPattern>> patterns) {
  100.         for (final Map.Entry<Integer, OperatingSystem.Builder> entry : builders.entrySet()) {
  101.             final SortedSet<OperatingSystemPattern> patternSet = patterns.get(entry.getKey());
  102.             if (patternSet != null) {
  103.                 entry.getValue().addPatterns(patternSet);
  104.             } else {
  105.                 LOG.debug("No patterns for operating system entry (with id '" + entry.getKey() + "') available.");
  106.             }
  107.         }
  108.     }

  110.     private static void addTypeToBrowser(final Map<Integer, Browser.Builder> builders, final Map<Integer, BrowserType> types) {
  111.         int typeId;
  112.         for (final Map.Entry<Integer, Browser.Builder> entry : builders.entrySet()) {
  113.             typeId = entry.getValue().getTypeId();
  114.             if (types.containsKey(typeId)) {
  115.                 entry.getValue().setType(types.get(typeId));
  116.             } else {
  117.                 LOG.warn("No type available for '" + entry.getValue().getProducer() + " " + entry.getValue().getFamily() + "'.");
  118.             }
  119.         }
  120.     }

  122.     private static Set<Browser> buildBrowsers(final Map<Integer, Browser.Builder> browserBuilders) {
  123.         final Set<Browser> browsers = new HashSet<Browser>();
  124.         for (final Map.Entry<Integer, Browser.Builder> entry : browserBuilders.entrySet()) {
  125.             try {
  126.                 browsers.add(entry.getValue().build());
  127.             } catch (final Exception e) {
  128.                 LOG.warn("Can not build browser: " + e.getLocalizedMessage());
  129.             }
  130.         }
  131.         return browsers;
  132.     }

  134.     private static Set<Device> buildDevices(final Map<Integer, Device.Builder> deviceBuilders) {
  135.         final Set<Device> devices = new HashSet<Device>();
  136.         for (final Map.Entry<Integer, Device.Builder> entry : deviceBuilders.entrySet()) {
  137.             try {
  138.                 devices.add(entry.getValue().build());
  139.             } catch (final Exception e) {
  140.                 LOG.warn("Can not build device '" + entry.getValue().getName() + "': " + e.getLocalizedMessage());
  141.             }
  142.         }
  143.         return devices;
  144.     }

  146.     private static Map<Integer, OperatingSystem> buildOperatingSystems(final Map<Integer, OperatingSystem.Builder> osBuilders) {
  147.         final Map<Integer, OperatingSystem> operatingSystems = new HashMap<Integer, OperatingSystem>();
  148.         for (final Map.Entry<Integer, OperatingSystem.Builder> entry : osBuilders.entrySet()) {
  149.             try {
  150.                 operatingSystems.put(entry.getKey(), entry.getValue().build());
  151.             } catch (final Exception e) {
  152.                 LOG.warn("Can not build operating system: " + e.getLocalizedMessage());
  153.             }
  154.         }
  155.         return operatingSystems;
  156.     }

  158.     private static SortedMap<BrowserPattern, Browser> buildPatternToBrowserMap(final Set<Browser> browserSet) {
  159.         final SortedMap<BrowserPattern, Browser> patternBrowser = new TreeMap<BrowserPattern, Browser>(BROWSER_PATTERN_COMPARATOR);
  160.         for (final Browser browser : browserSet) {
  161.             for (final BrowserPattern pattern : browser.getPatterns()) {
  162.                 patternBrowser.put(pattern, browser);
  163.             }
  164.         }
  165.         return patternBrowser;
  166.     }

  168.     private static SortedMap<DevicePattern, Device> buildPatternToDeviceMap(final Set<Device> devices) {
  169.         final SortedMap<DevicePattern, Device> patternDevice = new TreeMap<DevicePattern, Device>(DEVICE_PATTERN_COMPARATOR);
  170.         for (final Device device : devices) {
  171.             for (final DevicePattern pattern : device.getPatterns()) {
  172.                 patternDevice.put(pattern, device);
  173.             }
  174.         }
  175.         return patternDevice;
  176.     }

  178.     private static SortedMap<OperatingSystemPattern, OperatingSystem> buildPatternToOperatingSystemMap(final Set<OperatingSystem> osSet) {
  179.         final SortedMap<OperatingSystemPattern, OperatingSystem> map = new TreeMap<OperatingSystemPattern, OperatingSystem>(
  180.                 OS_PATTERN_COMPARATOR);
  181.         for (final OperatingSystem os : osSet) {
  182.             for (final OperatingSystemPattern pattern : os.getPatterns()) {
  183.                 map.put(pattern, os);
  184.             }
  185.         }
  186.         return map;
  187.     }

  189.     private static Map<Integer, Integer> convertBrowserOsMapping(final Set<BrowserOperatingSystemMapping> browserOperatingSystemMappings) {
  190.         final Map<Integer, Integer> result = new HashMap<Integer, Integer>();
  191.         for (final BrowserOperatingSystemMapping mapping : browserOperatingSystemMappings) {
  192.             result.put(mapping.getBrowserId(), mapping.getOperatingSystemId());
  193.         }
  194.         return result;
  195.     }

  197.     private static Set<OperatingSystem> convertOperatingSystems(final Map<Integer, OperatingSystem> operatingSystems) {
  198.         final Set<OperatingSystem> result = new HashSet<OperatingSystem>();
  199.         for (final Entry<Integer, OperatingSystem> entry : operatingSystems.entrySet()) {
  200.             result.add(entry.getValue());
  201.         }
  202.         return result;
  203.     }

  205.     @Nonnull
  206.     private final Map<Integer, BrowserType> browserTypes = new HashMap<Integer, BrowserType>();

  208.     @Nonnull
  209.     private final Map<Integer, SortedSet<BrowserPattern>> browserPatterns = new HashMap<Integer, SortedSet<BrowserPattern>>();

  211.     @Nonnull
  212.     private final Map<Integer, SortedSet<OperatingSystemPattern>> operatingSystemPatterns = new HashMap<Integer, SortedSet<OperatingSystemPattern>>();

  214.     @Nonnull
  215.     private final Map<Integer, Browser.Builder> browserBuilders = new HashMap<Integer, Browser.Builder>();

  217.     @Nonnull
  218.     private final Set<Browser> browsers = new HashSet<Browser>();

  220.     @Nonnull
  221.     private final Set<Device> devices = new HashSet<Device>();

  223.     @Nonnull
  224.     private final Map<Integer, Device.Builder> deviceBuilders = new HashMap<Integer, Device.Builder>();

  226.     @Nonnull
  227.     private final Map<Integer, SortedSet<DevicePattern>> devicePatterns = new HashMap<Integer, SortedSet<DevicePattern>>();

  229.     @Nonnull
  230.     private final Map<Integer, OperatingSystem.Builder> operatingSystemBuilders = new HashMap<Integer, OperatingSystem.Builder>();

  232.     @Nonnull
  233.     private final Set<OperatingSystem> operatingSystems = new HashSet<OperatingSystem>();

  235.     @Nonnull
  236.     private final List<Robot> robots = new ArrayList<Robot>();

  238.     private String version;

  240.     @Nonnull
  241.     private final Set<BrowserOperatingSystemMapping> browserToOperatingSystemMap = new HashSet<BrowserOperatingSystemMapping>();

  243.     private static final OrderedPatternComparator<BrowserPattern> BROWSER_PATTERN_COMPARATOR = new OrderedPatternComparator<BrowserPattern>();

  245.     private static final OrderedPatternComparator<DevicePattern> DEVICE_PATTERN_COMPARATOR = new OrderedPatternComparator<DevicePattern>();

  247.     private static final OrderedPatternComparator<OperatingSystemPattern> OS_PATTERN_COMPARATOR = new OrderedPatternComparator<OperatingSystemPattern>();

  249.     public DataBuilder appendBrowser(@Nonnull final Browser browser) {
  250.         Check.notNull(browser, "browser");

  252.         browsers.add(browser);
  253.         return this;
  254.     }

  256.     /**
  257.      * Appends a copy of the given {@code Browser.Builder} to the internal data structure.
  258.      * 
  259.      * @param browserBuilder
  260.      *            {@code Browser.Builder} to be copied and appended
  261.      * @return this {@code Builder}, for chaining
  262.      * @throws net.sf.qualitycheck.exception.IllegalNullArgumentException
  263.      *             if the given argument is {@code null}
  264.      * @throws net.sf.qualitycheck.exception.IllegalStateOfArgumentException
  265.      *             if the ID of the given builder is invalid
  266.      * @throws net.sf.qualitycheck.exception.IllegalStateOfArgumentException
  267.      *             if a builder with the same ID already exists
  268.      */
  269.     @Nonnull
  270.     public DataBuilder appendBrowserBuilder(@Nonnull final Browser.Builder browserBuilder) {
  271.         Check.notNull(browserBuilder, "browserBuilder");
  272.         Check.notNegative(browserBuilder.getId(), "browserBuilder.getId()");
  273.         if (browserBuilder.getType() == null && browserBuilder.getTypeId() < 0) {
  274.             throw new IllegalStateOfArgumentException("A Type or Type-ID of argument 'browserBuilder' must be set.");
  275.         }
  276.         if (browserBuilders.containsKey(browserBuilder.getId())) {
  277.             throw new IllegalStateOfArgumentException("The browser builder '" + browserBuilder.getProducer() + " "
  278.                     + browserBuilder.getFamily() + "' is already in the map.");
  279.         }

  281.         final Browser.Builder builder = browserBuilder.copy();
  282.         browserBuilders.put(builder.getId(), builder);
  283.         return this;
  284.     }

  286.     @Nonnull
  287.     public DataBuilder appendBrowserOperatingSystemMapping(@Nonnull final BrowserOperatingSystemMapping browserOsMapping) {
  288.         Check.notNull(browserOsMapping, "browserOsMapping");

  290.         browserToOperatingSystemMap.add(browserOsMapping);
  291.         return this;
  292.     }

  294.     /**
  295.      * Appends a browser pattern to the map of pattern sorted by ID.
  296.      * 
  297.      * @param pattern
  298.      *            a pattern for a browser
  299.      * @return itself
  300.      * @throws net.sf.qualitycheck.exception.IllegalNullArgumentException
  301.      *             if the given argument is {@code null}
  302.      */
  303.     @Nonnull
  304.     public DataBuilder appendBrowserPattern(@Nonnull final BrowserPattern pattern) {
  305.         Check.notNull(pattern, "pattern");
  306.         if (!browserPatterns.containsKey(pattern.getId())) {
  307.             browserPatterns.put(pattern.getId(), new TreeSet<BrowserPattern>(BROWSER_PATTERN_COMPARATOR));
  308.         }

  310.         browserPatterns.get(pattern.getId()).add(pattern);
  311.         return this;
  312.     }

  314.     @Nonnull
  315.     public DataBuilder appendBrowserType(@Nonnull final BrowserType type) {
  316.         Check.notNull(type, "type");

  318.         browserTypes.put(type.getId(), type);
  319.         return this;
  320.     }

  322.     public DataBuilder appendDevice(@Nonnull final Device device) {
  323.         Check.notNull(device, "device");

  325.         devices.add(device);
  326.         return this;
  327.     }

  329.     /**
  330.      * Appends a copy of the given {@code Device.Builder} to the internal data structure.
  331.      * 
  332.      * @param deviceBuilder
  333.      *            {@code Device.Builder} to be copied and appended
  334.      * @return this {@code Builder}, for chaining
  335.      * @throws net.sf.qualitycheck.exception.IllegalNullArgumentException
  336.      *             if the given argument is {@code null}
  337.      * @throws net.sf.qualitycheck.exception.IllegalStateOfArgumentException
  338.      *             if the ID of the given builder is invalid
  339.      * @throws net.sf.qualitycheck.exception.IllegalStateOfArgumentException
  340.      *             if a builder with the same ID already exists
  341.      */
  342.     @Nonnull
  343.     public DataBuilder appendDeviceBuilder(@Nonnull final Device.Builder deviceBuilder) {
  344.         Check.notNull(deviceBuilder, "deviceBuilder");
  345.         Check.notNegative(deviceBuilder.getId(), "deviceBuilder.getId()");
  346.         if (deviceBuilders.containsKey(deviceBuilder.getId())) {
  347.             throw new IllegalStateOfArgumentException("The device builder '" + deviceBuilder.getName() + "' is already in the map.");
  348.         }

  350.         final Device.Builder builder = deviceBuilder.copy();
  351.         deviceBuilders.put(builder.getId(), builder);
  352.         return this;
  353.     }

  355.     /**
  356.      * Appends a device pattern to the map of pattern sorted by ID.
  357.      * 
  358.      * @param pattern
  359.      *            a pattern for a device
  360.      * @return itself
  361.      * @throws net.sf.qualitycheck.exception.IllegalNullArgumentException
  362.      *             if the given argument is {@code null}
  363.      */
  364.     @Nonnull
  365.     public DataBuilder appendDevicePattern(@Nonnull final DevicePattern pattern) {
  366.         Check.notNull(pattern, "pattern");
  367.         if (!devicePatterns.containsKey(pattern.getId())) {
  368.             devicePatterns.put(pattern.getId(), new TreeSet<DevicePattern>(DEVICE_PATTERN_COMPARATOR));
  369.         }

  371.         devicePatterns.get(pattern.getId()).add(pattern);
  372.         return this;
  373.     }

  375.     @Nonnull
  376.     public DataBuilder appendOperatingSystem(@Nonnull final OperatingSystem operatingSystem) {
  377.         Check.notNull(operatingSystem, "operatingSystem");

  379.         operatingSystems.add(operatingSystem);
  380.         return this;
  381.     }

  383.     /**
  384.      * Appends a copy of the given {@code OperatingSystem.Builder} to the internal data structure.
  385.      * 
  386.      * @param operatingSystemBuilder
  387.      *            {@code OperatingSystem.Builder} to be copied and appended
  388.      * @return this {@code Builder}, for chaining
  389.      * @throws net.sf.qualitycheck.exception.IllegalNullArgumentException
  390.      *             if the given argument is {@code null}
  391.      * @throws net.sf.qualitycheck.exception.IllegalNegativeArgumentException
  392.      *             if the ID of the given builder is negative
  393.      * @throws net.sf.qualitycheck.exception.IllegalStateOfArgumentException
  394.      *             if a builder with the same ID already exists
  395.      */
  396.     @Nonnull
  397.     public DataBuilder appendOperatingSystemBuilder(@Nonnull final OperatingSystem.Builder operatingSystemBuilder) {
  398.         Check.notNull(operatingSystemBuilder, "operatingSystemBuilder");
  399.         Check.notNegative(operatingSystemBuilder.getId(), "operatingSystemBuilder.getId()");
  400.         Check.stateIsTrue(!operatingSystemBuilders.containsKey(operatingSystemBuilder.getId()),
  401.                 "Operating system builder with ID '%s' already exists.", operatingSystemBuilder.getId());

  403.         final OperatingSystem.Builder builder = operatingSystemBuilder.copy();
  404.         operatingSystemBuilders.put(builder.getId(), builder);
  405.         return this;
  406.     }

  408.     /**
  409.      * Appends an operating system pattern to the map of pattern sorted by ID.
  410.      * 
  411.      * @param pattern
  412.      *            a pattern for a browser
  413.      * @throws net.sf.qualitycheck.exception.IllegalNullArgumentException
  414.      *             if the pattern is {@code null}
  415.      * @return itself
  416.      */
  417.     @Nonnull
  418.     public DataBuilder appendOperatingSystemPattern(@Nonnull final OperatingSystemPattern pattern) {
  419.         Check.notNull(pattern, "pattern");

  421.         if (!operatingSystemPatterns.containsKey(pattern.getId())) {
  422.             operatingSystemPatterns.put(pattern.getId(), new TreeSet<OperatingSystemPattern>(OS_PATTERN_COMPARATOR));
  423.         }

  425.         operatingSystemPatterns.get(pattern.getId()).add(pattern);
  426.         return this;
  427.     }

  429.     @Nonnull
  430.     public DataBuilder appendRobot(@Nonnull final Robot robot) {
  431.         Check.notNull(robot, "robot");

  433.         robots.add(robot);
  434.         return this;
  435.     }

  437.     @Nonnull
  438.     public Data build() {
  439.         addTypeToBrowser(browserBuilders, browserTypes);
  440.         addPatternToBrowser(browserBuilders, browserPatterns);
  441.         addPatternToOperatingSystem(operatingSystemBuilders, operatingSystemPatterns);
  442.         addPatternToDevice(deviceBuilders, devicePatterns);

  444.         final Map<Integer, OperatingSystem> systems = buildOperatingSystems(operatingSystemBuilders);
  445.         addOperatingSystemToBrowser(browserBuilders, systems, convertBrowserOsMapping(browserToOperatingSystemMap));

  447.         final Set<OperatingSystem> osSet = convertOperatingSystems(systems);
  448.         osSet.addAll(operatingSystems);

  450.         final Set<Browser> browserSet = buildBrowsers(browserBuilders);
  451.         browserSet.addAll(browsers);

  453.         final Set<Device> deviceSet = buildDevices(deviceBuilders);
  454.         deviceSet.addAll(devices);

  456.         final SortedMap<BrowserPattern, Browser> patternToBrowserMap = buildPatternToBrowserMap(browserSet);
  457.         final SortedMap<OperatingSystemPattern, OperatingSystem> patternToOperatingSystemMap = buildPatternToOperatingSystemMap(osSet);
  458.         final SortedMap<DevicePattern, Device> patternToDeviceMap = buildPatternToDeviceMap(deviceSet);

  460.         return new Data(browserSet, browserPatterns, browserTypes, patternToBrowserMap, browserToOperatingSystemMap, osSet,
  461.                 operatingSystemPatterns, patternToOperatingSystemMap, robots, deviceSet, devicePatterns, patternToDeviceMap, version);
  462.     }

  464.     @Nonnull
  465.     public DataBuilder setVersion(@Nonnull final String version) {
  466.         Check.notNull(version, "version");

  468.         this.version = version;
  469.         return this;
  470.     }

  472. }
Created with JaCoCo 0.6.2.201302030002