Пример #1
0
  @SqlNullable
  @Description("extract query parameter from url")
  @ScalarFunction
  @LiteralParameters({"x", "y"})
  @SqlType("varchar(x)")
  public static Slice urlExtractParameter(
      @SqlType("varchar(x)") Slice url, @SqlType("varchar(y)") Slice parameterName) {
    URI uri = parseUrl(url);
    if ((uri == null) || (uri.getQuery() == null)) {
      return null;
    }

    Slice query = slice(uri.getQuery());
    String parameter = parameterName.toStringUtf8();
    Iterable<String> queryArgs = QUERY_SPLITTER.split(query.toStringUtf8());

    for (String queryArg : queryArgs) {
      Iterator<String> arg = ARG_SPLITTER.split(queryArg).iterator();
      if (arg.next().equals(parameter)) {
        if (arg.hasNext()) {
          return utf8Slice(arg.next());
        }
        // first matched key is empty
        return Slices.EMPTY_SLICE;
      }
    }

    // no key matched
    return null;
  }
Пример #2
0
 @GET
 @Path("/{id}/xref")
 @ApiOperation(httpMethod = "GET", value = "Retrieves all the external references for the ID")
 public Response getByFeatureId(
     @PathParam("id") String query, @DefaultValue("") @QueryParam("dbname") String dbname) {
   try {
     checkParams();
     XRefsDBAdaptor xRefDBAdaptor = dbAdaptorFactory.getXRefDBAdaptor(this.species, this.assembly);
     if (!dbname.equals("")) {
       queryOptions.put("dbname", Splitter.on(",").splitToList(dbname));
     }
     return createOkResponse(
         xRefDBAdaptor.getAllByDBNameList(Splitter.on(",").splitToList(query), queryOptions));
     //            if (dbName.equals("")) {
     //                return generateResponse(query, "XREF",
     // x.getAllByDBNameList(Splitter.on(",").splitToList(query), null));
     //            }
     //            else {
     //                return generateResponse(query, "XREF",
     // x.getAllByDBNameList(Splitter.on(",").splitToList(query),
     // Splitter.on(",").splitToList(dbName)));
     //            }
   } catch (Exception e) {
     e.printStackTrace();
     return createErrorResponse("getAllByAccessions", e.toString());
   }
 }
Пример #3
0
  public void loadGridNet(String mapGrid) throws IOException {
    Preconditions.checkArgument(!Strings.isNullOrEmpty(mapGrid));

    logger.debug("loading {}...", mapGrid);

    CSVReader reader = new CSVReader(new FileReader(mapGrid), ',', '"', 1);
    String[] row;
    while ((row = reader.readNext()) != null) {
      String gridId = row[1].trim();
      String dmRoads = row[2].trim();
      String gjRoads = row[3].trim();

      Set<String> x =
          Sets.newHashSet(Splitter.on('|').trimResults().omitEmptyStrings().split(dmRoads));
      Set<String> y =
          Sets.newHashSet(Splitter.on('|').trimResults().omitEmptyStrings().split(gjRoads));
      if (x.size() > 0 || y.size() > 0) {
        MapGrid grid = new MapGrid();
        grid.dmRoads = x;
        grid.gjRoads = y;

        gridNet.put(gridId, grid);
        //                logger.debug("{},{},{}", gridId, x, y);
      }
    }

    reader.close();
  }
Пример #4
0
 public void setupLoadOnly(String deobfFileName, boolean loadAll) {
   try {
     File mapData = new File(deobfFileName);
     LZMAInputSupplier zis = new LZMAInputSupplier(new FileInputStream(mapData));
     InputSupplier<InputStreamReader> srgSupplier =
         CharStreams.newReaderSupplier(zis, Charsets.UTF_8);
     List<String> srgList = CharStreams.readLines(srgSupplier);
     rawMethodMaps = Maps.newHashMap();
     rawFieldMaps = Maps.newHashMap();
     Builder<String, String> builder = ImmutableBiMap.<String, String>builder();
     Builder<String, String> mcpBuilder = ImmutableBiMap.<String, String>builder();
     Splitter splitter = Splitter.on(CharMatcher.anyOf(": ")).omitEmptyStrings().trimResults();
     for (String line : srgList) {
       String[] parts = Iterables.toArray(splitter.split(line), String.class);
       String typ = parts[0];
       if ("CL".equals(typ)) {
         parseClass(builder, parts);
         parseMCPClass(mcpBuilder, parts);
       } else if ("MD".equals(typ) && loadAll) {
         parseMethod(parts);
       } else if ("FD".equals(typ) && loadAll) {
         parseField(parts);
       }
     }
     classNameBiMap = builder.build();
     mcpNameBiMap = mcpBuilder.build();
   } catch (IOException ioe) {
     FMLRelaunchLog.log(Level.ERROR, "An error occurred loading the deobfuscation map data", ioe);
   }
   methodNameMaps = Maps.newHashMapWithExpectedSize(rawMethodMaps.size());
   fieldNameMaps = Maps.newHashMapWithExpectedSize(rawFieldMaps.size());
 }
  @Override
  public Collection<Either<JobSpec, URI>> parseJobSpec(byte[] message) throws IOException {
    try {
      String messageString = new String(message, Charsets.UTF_8);
      List<Either<JobSpec, URI>> jobSpecs = Lists.newArrayList();

      for (String oneInstruction : SPLITTER_COMMA.split(messageString)) {

        List<String> tokens = SPLITTER_COLON.splitToList(oneInstruction);

        if (tokens.get(0).equals(REMOVE)) {
          URI uri = new URI(tokens.get(1));
          jobSpecs.add(Either.<JobSpec, URI>right(uri));
        } else {
          URI uri = new URI(tokens.get(0));
          String version = tokens.get(1);
          JobSpec jobSpec =
              new JobSpec.Builder(uri)
                  .withConfig(ConfigFactory.empty())
                  .withVersion(version)
                  .build();
          jobSpecs.add(Either.<JobSpec, URI>left(jobSpec));
        }
      }
      return jobSpecs;
    } catch (URISyntaxException use) {
      throw new IOException(use);
    }
  }
Пример #6
0
 public static Map<FormatBundle, Map<Integer, List<Path>>> getFormatNodeMap(JobContext job) {
   Map<FormatBundle, Map<Integer, List<Path>>> formatNodeMap = Maps.newHashMap();
   Configuration conf = job.getConfiguration();
   String crunchInputs = conf.get(CRUNCH_INPUTS);
   if (crunchInputs == null || crunchInputs.isEmpty()) {
     return ImmutableMap.of();
   }
   for (String input : Splitter.on(RECORD_SEP).split(crunchInputs)) {
     List<String> fields = Lists.newArrayList(SPLITTER.split(input));
     FormatBundle<InputFormat> inputBundle =
         FormatBundle.fromSerialized(fields.get(0), job.getConfiguration());
     if (!formatNodeMap.containsKey(inputBundle)) {
       formatNodeMap.put(inputBundle, Maps.<Integer, List<Path>>newHashMap());
     }
     Integer nodeIndex = Integer.valueOf(fields.get(1));
     if (!formatNodeMap.get(inputBundle).containsKey(nodeIndex)) {
       formatNodeMap.get(inputBundle).put(nodeIndex, Lists.<Path>newLinkedList());
     }
     List<Path> formatNodePaths = formatNodeMap.get(inputBundle).get(nodeIndex);
     String paths = fields.get(2);
     for (String path : Splitter.on(PATH_SEP).split(paths)) {
       formatNodePaths.add(new Path(path));
     }
   }
   return formatNodeMap;
 }
Пример #7
0
 @GET
 @Path("/{id}/contains")
 /*
     @ApiOperation(httpMethod = "GET", value = "Get the genes that contain the given string")
 */
 public Response getByContainsQuery(@PathParam("id") String query) {
   try {
     checkParams();
     XRefsDBAdaptor x = dbAdaptorFactory.getXRefDBAdaptor(this.species, this.assembly);
     List<List<Xref>> xrefs = x.getByContainsQueryList(Splitter.on(",").splitToList(query));
     if (query.startsWith("rs")
         || query.startsWith("AFFY_")
         || query.startsWith("SNP_")
         || query.startsWith("VAR_")
         || query.startsWith("CRTAP_")
         || query.startsWith("FKBP10_")
         || query.startsWith("LEPRE1_")
         || query.startsWith("PPIB_")) {
       List<QueryResult> snpXrefs =
           x.getByStartsWithSnpQueryList(Splitter.on(",").splitToList(query), queryOptions);
       //                for (List<Xref> xrefList : snpXrefs) {
       //                    xrefs.get(0).addAll(xrefList);
       //                }
     }
     return generateResponse(query, xrefs);
   } catch (Exception e) {
     e.printStackTrace();
     return createErrorResponse("getAllByAccessions", e.toString());
   }
 }
  @Test
  public void testFromSystem_containsListValues() throws Exception {
    AbstractConfiguration.setDefaultListDelimiter('|');
    Map<String, String> properties = Maps.newHashMap();
    properties.put("testProperty", "b,bee");

    for (Entry<String, String> entry : properties.entrySet()) {
      System.setProperty(entry.getKey(), entry.getValue());
    }

    Splitter splitter = Splitter.on(',');
    Configuration systemConfiguration = configurationHelper.fromSystem();
    for (Entry<String, String> entry : properties.entrySet()) {
      String[] actualValues = systemConfiguration.getStringArray(entry.getKey());
      String[] expectedValues;
      if ("line.separator".equals(entry.getKey())) {
        expectedValues = new String[] {SystemUtils.LINE_SEPARATOR};
      } else {
        expectedValues = splitter.splitToList(entry.getValue()).toArray(new String[0]);
      }
      assertArrayEquals(
          String.format("Values for key %s do not match", entry.getKey()),
          expectedValues,
          actualValues);
    }
  }
Пример #9
0
 @IMCCallback
 public void processIMCRequests(FMLInterModComms.IMCEvent event) {
   Splitter splitter = Splitter.on("@").trimResults();
   for (IMCMessage m : event.getMessages()) {
     if ("add-facade".equals(m.key)) {
       String[] array = Iterables.toArray(splitter.split(m.getStringValue()), String.class);
       if (array.length != 2) {
         Logger.getLogger("Buildcraft")
             .log(
                 Level.INFO,
                 String.format(
                     "Received an invalid add-facade request %s from mod %s",
                     m.getStringValue(), m.getSender()));
         continue;
       }
       Integer blId = Ints.tryParse(array[0]);
       Integer metaId = Ints.tryParse(array[1]);
       if (blId == null || metaId == null) {
         Logger.getLogger("Buildcraft")
             .log(
                 Level.INFO,
                 String.format(
                     "Received an invalid add-facade request %s from mod %s",
                     m.getStringValue(), m.getSender()));
         continue;
       }
       ItemFacade.addFacade(new ItemStack(blId, 1, metaId));
     }
   }
 }
 @Singleton
 @Iso3166
 @Override
 public Map<String, Set<String>> get() {
   Builder<String, Set<String>> codes = ImmutableMap.<String, Set<String>>builder();
   for (String key : ImmutableSet.of(PROPERTY_REGION, PROPERTY_ZONE))
     try {
       String regionString = injector.getInstance(Key.get(String.class, named(key + "s")));
       for (String region : Splitter.on(',').split(regionString)) {
         try {
           codes.put(
               region,
               ImmutableSet.copyOf(
                   Splitter.on(',')
                       .split(
                           injector.getInstance(
                               Key.get(
                                   String.class,
                                   named(key + "." + region + "." + ISO3166_CODES))))));
         } catch (ConfigurationException e) {
           // this happens if regions property isn't set
           // services not run by AWS may not have regions, so this is ok.
         }
       }
     } catch (ConfigurationException e) {
       // this happens if regions property isn't set
       // services not run by AWS may not have regions, so this is ok.
     }
   return codes.build();
 }
Пример #11
0
 private static ImmutableMap<String, String> getQueryMap(final String query)
     throws MalformedRequestException {
   if (StringUtils.isBlank(query)) {
     return ImmutableMap.of();
   } else {
     final Iterable<String> params = Splitter.on('&').split(query);
     final ImmutableMap.Builder<String, String> map = ImmutableMap.builder();
     for (final String param : params) {
       final ImmutableList<String> strings = ImmutableList.copyOf(Splitter.on('=').split(param));
       final String name = strings.get(0);
       if (strings.size() > 2) {
         throw new MalformedRequestException("Multiple '=' for parameter " + name);
       }
       final String value;
       if (strings.size() > 1) {
         value = strings.get(1);
       } else {
         value = null;
       }
       if (map.build().keySet().contains(name)) {
         throw new MalformedRequestException("Duplicate value for parameter " + name);
       }
       map.put(name, value);
     }
     return map.build();
   }
 }
Пример #12
0
  public Map<String, Path> buildMultipleAndReturnOutputs(String... args) throws IOException {
    // Add in `--show-output` to the build, so we can parse the output paths after the fact.
    ImmutableList<String> buildArgs =
        ImmutableList.<String>builder().add("--show-output").add(args).build();
    ProjectWorkspace.ProcessResult buildResult =
        runBuckBuild(buildArgs.toArray(new String[buildArgs.size()]));
    buildResult.assertSuccess();

    // Grab the stdout lines, which have the build outputs.
    List<String> lines =
        Splitter.on(CharMatcher.anyOf(System.lineSeparator()))
            .trimResults()
            .omitEmptyStrings()
            .splitToList(buildResult.getStdout());

    // Skip the first line, which is just "The outputs are:".
    assertThat(lines.get(0), Matchers.equalTo("The outputs are:"));
    lines = lines.subList(1, lines.size());

    Splitter lineSplitter = Splitter.on(' ').trimResults();
    ImmutableMap.Builder<String, Path> builder = ImmutableMap.builder();
    for (String line : lines) {
      List<String> fields = lineSplitter.splitToList(line);
      assertThat(fields, Matchers.hasSize(2));
      builder.put(fields.get(0), getPath(fields.get(1)));
    }

    return builder.build();
  }
Пример #13
0
  /**
   * Creates the list of comparables
   *
   * @since $version
   * @author hceylan
   */
  private void createComparables() {
    // order on id
    if (this.mapping.getOrderBy().trim().length() == 0) {
      if (this.mapping.isAssociation()) {
        final EntityTypeImpl<E> type = ((PluralAssociationMapping<?, ?, E>) this.mapping).getType();
        if (type.hasSingleIdAttribute()) {
          this.comparables.add(new ComparableMapping(true, (Mapping<?, ?, ?>) type.getIdMapping()));
        } else {
          for (final Pair<BasicMapping<? super E, ?>, BasicAttribute<?, ?>> pair :
              type.getIdMappings()) {
            this.comparables.add(new ComparableMapping(true, pair.getFirst()));
          }
        }
      } else if (this.mapping.getType().getPersistenceType() == PersistenceType.EMBEDDABLE) {
        throw new MappingException(
            "Embeddable element collections requires OrderBy value",
            this.mapping.getAttribute().getLocator());
      } else {
        this.comparables.add(new ComparableMapping(true, null));
      }
    } else {
      final Iterator<String> i =
          Splitter.on(",").trimResults().split(this.mapping.getOrderBy()).iterator();
      while (i.hasNext()) {
        final Iterator<String> j = Splitter.on(" ").trimResults().split(i.next()).iterator();

        int index = 0;
        String path = null;
        boolean order = true;
        while (j.hasNext()) {
          if (index == 0) {
            path = j.next();
          } else if (index == 1) {
            order = "ASC".equals(j.next().toUpperCase());
          } else {
            throw new MappingException(
                "Invalid order by statement: " + this.mapping.getOrderBy() + ".",
                this.mapping.getAttribute().getLocator());
          }

          index++;
        }

        if (this.mapping.getType().getPersistenceType() == PersistenceType.BASIC) {
          throw new MappingException(
              "Basic element collection must not have OrderBy value",
              this.mapping.getAttribute().getLocator());
        }

        final Mapping<?, ?, ?> mapping = this.mapping.getMapping(path);
        if (mapping == null) {
          throw new MappingException(
              "Sort property cannot be found: " + path, this.mapping.getAttribute().getLocator());
        }

        this.comparables.add(new ComparableMapping(order, mapping));
      }
    }
  }
Пример #14
0
  @Test
  public void shouldTrimWhiteSpaceStrings() {
    Splitter splitter = Splitter.on(',').trimResults();

    Iterable<String> result = splitter.split("foo, bar, baz");

    assertEquals(newArrayList("foo", "bar", "baz"), newArrayList(result));
  }
Пример #15
0
  @Test
  public void shouldOmitEmptyStrings() {
    Splitter splitter = Splitter.on(',').omitEmptyStrings();

    Iterable<String> result = splitter.split("foo,bar,,baz");

    assertEquals(newArrayList("foo", "bar", "baz"), newArrayList(result));
  }
  /**
   * Get a {@link org.kitesdk.data.PartitionKey} corresponding to a partition's filesystem path
   * represented as a {@link URI}. If the path is not a valid partition, then {@link
   * IllegalArgumentException} is thrown. Note that the partition does not have to exist.
   *
   * @param dataset the filesystem dataset
   * @param partitionPath a directory path where the partition data is stored
   * @return a partition key representing the partition at the given path
   * @since 0.4.0
   */
  @SuppressWarnings("deprecation")
  public static PartitionKey partitionKeyForPath(Dataset dataset, URI partitionPath) {
    Preconditions.checkState(
        dataset.getDescriptor().isPartitioned(),
        "Attempt to get a partition on a non-partitioned dataset (name:%s)",
        dataset.getName());

    Preconditions.checkArgument(
        dataset instanceof FileSystemDataset, "Dataset is not a FileSystemDataset");
    FileSystemDataset fsDataset = (FileSystemDataset) dataset;

    FileSystem fs = fsDataset.getFileSystem();
    URI partitionUri = fs.makeQualified(new Path(partitionPath)).toUri();
    URI directoryUri = fsDataset.getDirectory().toUri();
    URI relativizedUri = directoryUri.relativize(partitionUri);

    if (relativizedUri.equals(partitionUri)) {
      throw new IllegalArgumentException(
          String.format(
              "Partition URI %s has different " + "root directory to dataset (directory: %s).",
              partitionUri, directoryUri));
    }

    Iterable<String> parts = Splitter.on('/').split(relativizedUri.getPath());

    PartitionStrategy partitionStrategy = dataset.getDescriptor().getPartitionStrategy();
    List<FieldPartitioner> fieldPartitioners = partitionStrategy.getFieldPartitioners();
    if (Iterables.size(parts) > fieldPartitioners.size()) {
      throw new IllegalArgumentException(
          String.format(
              "Too many partition directories " + "for %s (%s), expecting %s.",
              partitionUri, Iterables.size(parts), fieldPartitioners.size()));
    }

    List<Object> values = Lists.newArrayList();
    int i = 0;
    for (String part : parts) {
      Iterator<String> split = Splitter.on('=').split(part).iterator();
      String fieldName = split.next();
      FieldPartitioner fp = fieldPartitioners.get(i++);
      if (!fieldName.equals(fp.getName())) {
        throw new IllegalArgumentException(
            String.format(
                "Unrecognized partition name " + "'%s' in partition %s, expecting '%s'.",
                fieldName, partitionUri, fp.getName()));
      }
      if (!split.hasNext()) {
        throw new IllegalArgumentException(
            String.format(
                "Missing partition value for " + "'%s' in partition %s.", fieldName, partitionUri));
      }
      String stringValue = split.next();
      Object value = fp.valueFromString(stringValue);
      values.add(value);
    }
    return org.kitesdk.data.impl.Accessor.getDefault()
        .newPartitionKey(values.toArray(new Object[values.size()]));
  }
Пример #17
0
 protected void setupCredentials() {
   identity = System.getProperty("test." + provider + ".identity", "administrator");
   credential = System.getProperty("test." + provider + ".credential", "12345");
   endpoint =
       URI.create(System.getProperty("test." + provider + ".endpoint", "http://localhost:18083/"));
   apiVersion = System.getProperty("test." + provider + ".apiversion", "4.1.2r73507");
   majorVersion = Iterables.get(Splitter.on('r').split(apiVersion), 0);
   minorVersion = Iterables.get(Splitter.on('r').split(apiVersion), 1);
 }
Пример #18
0
 public NameParts(final String dn) {
   final ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
   for (final String chunk : Splitter.on(',').trimResults().split(dn)) {
     List<String> pairs = ImmutableList.copyOf(Splitter.on('=').trimResults().split(chunk));
     if (pairs.size() == 2) {
       builder.put(pairs.get(0), pairs.get(1));
     }
   }
   original = dn;
   parts = builder.build();
 }
Пример #19
0
 /**
  * Constructs a ApplicationBundler.
  *
  * @param excludePackages Class packages to exclude
  * @param includePackages Always includes classes/resources in these packages. Note that classes
  *     in these packages will not get inspected for dependencies.
  */
 public ApplicationBundler(Iterable<String> excludePackages, Iterable<String> includePackages) {
   this.excludePackages = ImmutableList.copyOf(excludePackages);
   this.includePackages = ImmutableList.copyOf(includePackages);
   this.acceptClassPath =
       Sets.difference(
           Sets.newHashSet(
               Splitter.on(File.pathSeparatorChar).split(System.getProperty("java.class.path"))),
           Sets.newHashSet(
               Splitter.on(File.pathSeparatorChar)
                   .split(System.getProperty("sun.boot.class.path"))));
 }
Пример #20
0
 private ImmutableSetMultimap<String, String> parsePermissions(
     @Nullable String database, Ini.Section rolesSection, Ini.Section groupsSection) {
   ImmutableSetMultimap.Builder<String, String> resultBuilder = ImmutableSetMultimap.builder();
   Multimap<String, String> roleNameToPrivilegeMap = HashMultimap.create();
   List<? extends RoleValidator> validators =
       Lists.newArrayList(
           new ServersAllIsInvalid(),
           new DatabaseMustMatch(),
           new DatabaseRequiredInRole(),
           new ServerNameMustMatch(serverName));
   for (Map.Entry<String, String> entry : rolesSection.entrySet()) {
     String roleName = Strings.nullToEmpty(entry.getKey()).trim();
     String roleValue = Strings.nullToEmpty(entry.getValue()).trim();
     boolean invalidConfiguration = false;
     if (roleName.isEmpty()) {
       LOGGER.warn("Empty role name encountered in {}", resourcePath);
       invalidConfiguration = true;
     }
     if (roleValue.isEmpty()) {
       LOGGER.warn("Empty role value encountered in {}", resourcePath);
       invalidConfiguration = true;
     }
     if (roleNameToPrivilegeMap.containsKey(roleName)) {
       LOGGER.warn("Role {} defined twice in {}", roleName, resourcePath);
     }
     Set<String> roles = PermissionUtils.toPermissionStrings(roleValue);
     if (!invalidConfiguration && roles != null) {
       for (String role : roles) {
         for (RoleValidator validator : validators) {
           validator.validate(database, role.trim());
         }
       }
       roleNameToPrivilegeMap.putAll(roleName, roles);
     }
   }
   Splitter roleSplitter = ROLE_SPLITTER.omitEmptyStrings().trimResults();
   for (Map.Entry<String, String> entry : groupsSection.entrySet()) {
     String groupName = Strings.nullToEmpty(entry.getKey()).trim();
     String groupPrivileges = Strings.nullToEmpty(entry.getValue()).trim();
     Collection<String> resolvedGroupPrivileges = Sets.newHashSet();
     for (String roleName : roleSplitter.split(groupPrivileges)) {
       if (roleNameToPrivilegeMap.containsKey(roleName)) {
         resolvedGroupPrivileges.addAll(roleNameToPrivilegeMap.get(roleName));
       } else {
         LOGGER.warn(
             "Role {} for group {} does not exist in privileges section in {}",
             new Object[] {roleName, groupName, resourcePath});
       }
     }
     resultBuilder.putAll(groupName, resolvedGroupPrivileges);
   }
   return resultBuilder.build();
 }
Пример #21
0
 public void testBuildImage() throws IOException, InterruptedException, URISyntaxException {
   BuildOptions options = BuildOptions.Builder.tag("testBuildImage").verbose(false).nocache(false);
   InputStream buildImageStream =
       api().build(new File(Resources.getResource("Dockerfile").toURI()), options);
   String buildStream = consumeStream(buildImageStream, false);
   Iterable<String> splitted = Splitter.on("\n").split(buildStream.replace("\r", "").trim());
   String lastStreamedLine = Iterables.getLast(splitted).trim();
   String rawImageId =
       Iterables.getLast(Splitter.on("Successfully built ").split(lastStreamedLine));
   String imageId = rawImageId.substring(0, 11);
   Image image = api().inspectImage(imageId);
   api().deleteImage(image.getId(), DeleteImageOptions.Builder.force(true));
 }
  /**
   * Get HttpResourceModel which matches the HttpMethod of the request.
   *
   * @param routableDestinations List of ResourceModels.
   * @param targetHttpMethod HttpMethod.
   * @param requestUri request URI.
   * @return RoutableDestination that matches httpMethod that needs to be handled. null if there are
   *     no matches.
   */
  private List<PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel>>
      getMatchedDestination(
          List<PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel>>
              routableDestinations,
          HttpMethod targetHttpMethod,
          String requestUri) {

    Iterable<String> requestUriParts = Splitter.on('/').omitEmptyStrings().split(requestUri);
    List<PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel>> matchedDestinations =
        Lists.newArrayListWithExpectedSize(routableDestinations.size());
    int maxExactMatch = 0;
    int maxGroupMatch = 0;
    int maxPatternLength = 0;

    for (PatternPathRouterWithGroups.RoutableDestination<HttpResourceModel> destination :
        routableDestinations) {
      HttpResourceModel resourceModel = destination.getDestination();
      int groupMatch = destination.getGroupNameValues().size();

      for (HttpMethod httpMethod : resourceModel.getHttpMethod()) {
        if (targetHttpMethod.equals(httpMethod)) {

          int exactMatch =
              getExactPrefixMatchCount(
                  requestUriParts,
                  Splitter.on('/').omitEmptyStrings().split(resourceModel.getPath()));

          // When there are multiple matches present, the following precedence order is used -
          // 1. template path that has highest exact prefix match with the url is chosen.
          // 2. template path has the maximum groups is chosen.
          // 3. finally, template path that has the longest length is chosen.
          if (exactMatch > maxExactMatch) {
            maxExactMatch = exactMatch;
            maxGroupMatch = groupMatch;
            maxPatternLength = resourceModel.getPath().length();

            matchedDestinations.clear();
            matchedDestinations.add(destination);
          } else if (exactMatch == maxExactMatch && groupMatch >= maxGroupMatch) {
            if (groupMatch > maxGroupMatch || resourceModel.getPath().length() > maxPatternLength) {
              maxGroupMatch = groupMatch;
              maxPatternLength = resourceModel.getPath().length();
              matchedDestinations.clear();
            }
            matchedDestinations.add(destination);
          }
        }
      }
    }
    return matchedDestinations;
  }
Пример #23
0
 private static String getPackageName(final String qualifiedName, final boolean strict) {
   Splitter _on = Splitter.on(".");
   Iterable<String> _split = _on.split(qualifiedName);
   final List<String> segments = IterableExtensions.<String>toList(_split);
   int _size = segments.size();
   boolean _equals = (_size == 1);
   if (_equals) {
     return "";
   }
   if (strict) {
     int _length = ((Object[]) Conversions.unwrapArray(segments, Object.class)).length;
     int _minus = (_length - 1);
     final List<String> packageSegments = segments.subList(0, _minus);
     final Function1<String, Boolean> _function =
         (String it) -> {
           char _charAt = it.charAt(0);
           return Boolean.valueOf(Character.isUpperCase(_charAt));
         };
     Iterable<String> _filter = IterableExtensions.<String>filter(packageSegments, _function);
     boolean _isEmpty = IterableExtensions.isEmpty(_filter);
     boolean _not = (!_isEmpty);
     if (_not) {
       throw new IllegalArgumentException(
           (("Cannot determine the package name of \'" + qualifiedName)
               + "\'. Please use the TypeReference(packageName, className) constructor"));
     }
     return IterableExtensions.join(packageSegments, ".");
   } else {
     int _length_1 = ((Object[]) Conversions.unwrapArray(segments, Object.class)).length;
     int _minus_1 = (_length_1 - 1);
     List<String> packageSegments_1 = segments.subList(0, _minus_1);
     while ((!packageSegments_1.isEmpty())) {
       String _last = IterableExtensions.<String>last(packageSegments_1);
       char _charAt = _last.charAt(0);
       boolean _isUpperCase = Character.isUpperCase(_charAt);
       if (_isUpperCase) {
         final List<String> _converted_packageSegments_1 = (List<String>) packageSegments_1;
         int _length_2 =
             ((Object[]) Conversions.unwrapArray(_converted_packageSegments_1, Object.class))
                 .length;
         int _minus_2 = (_length_2 - 1);
         List<String> _subList = packageSegments_1.subList(0, _minus_2);
         packageSegments_1 = _subList;
       } else {
         return IterableExtensions.join(packageSegments_1, ".");
       }
     }
     return "";
   }
 }
Пример #24
0
 private static LibraryDeps fromReaderEx(Reader reader) throws Exception {
   LibraryDeps deps = new LibraryDeps();
   BufferedReader buf = new BufferedReader(reader);
   // Check version.
   {
     String line = buf.readLine();
     if (!Objects.equal(line, VERSION)) {
       return deps;
     }
   }
   // Read units dependencies.
   String relPath;
   while (null != (relPath = buf.readLine())) {
     Source source = new Source();
     // Read flags.
     source.shouldRecompileOnAnyTopLevelChange = Boolean.parseBoolean(buf.readLine());
     // Read top symbols.
     {
       String line = buf.readLine();
       Iterable<String> topSymbols = Splitter.on(' ').omitEmptyStrings().split(line);
       Iterables.addAll(source.topSymbols, topSymbols);
     }
     // Read all symbols.
     {
       String line = buf.readLine();
       Iterable<String> allSymbols = Splitter.on(' ').omitEmptyStrings().split(line);
       Iterables.addAll(source.allSymbols, allSymbols);
     }
     // Read holes.
     {
       String line = buf.readLine();
       Iterable<String> holes = Splitter.on(' ').omitEmptyStrings().split(line);
       Iterables.addAll(source.holes, holes);
     }
     // Read dependencies.
     while (true) {
       String line = buf.readLine();
       // Blank line: next unit.
       if (line.length() == 0) {
         break;
       }
       // Parse line.
       String[] parts = line.split(" ");
       source.deps.add(new Dependency(new URI(parts[0]), parts[1], Long.parseLong(parts[2])));
     }
     // Remember dependencies for current unit.
     deps.sources.put(relPath, source);
   }
   return deps;
 }
Пример #25
0
  private static Splitter createSplitter(char separator, char... otherSeparators) {
    if (otherSeparators.length == 0) {
      return Splitter.on(separator).omitEmptyStrings();
    }

    // TODO(cgdecker): When CharMatcher is out of @Beta, us Splitter.on(CharMatcher)
    StringBuilder patternBuilder = new StringBuilder();
    patternBuilder.append("[");
    appendToRegex(separator, patternBuilder);
    for (char other : otherSeparators) {
      appendToRegex(other, patternBuilder);
    }
    patternBuilder.append("]");
    return Splitter.onPattern(patternBuilder.toString()).omitEmptyStrings();
  }
  @BeforeClass
  public static void setUp() throws IOException {
    InputStream dataFileInputStream =
        NaraSoundexTest.class.getResourceAsStream("DaitchMokotoffSoundexTest.data");
    List<String> lines = CharStreams.readLines(new InputStreamReader(dataFileInputStream));

    for (String currentLine : lines) {
      if (!currentLine.startsWith(";")) {
        Iterable<String> components = Splitter.on("->").trimResults().split(currentLine);
        Iterable<String> expectedValues =
            Splitter.on(",").trimResults().split(Iterables.get(components, 1));
        testCases.putAll(Iterables.get(components, 0), expectedValues);
      }
    }
  }
Пример #27
0
  public void shouldSplitIntoList() {
    final String input = "first , second , third , fourth ,,, seventh";

    assertEquals(
        Lists.newArrayList("first ", " second ", " third ", " fourth ", "", "", " seventh"),
        Lists.newArrayList(Splitter.on(",").split(input)));

    assertEquals(
        Lists.newArrayList("first ", " second ", " third ", " fourth ", " seventh"),
        Lists.newArrayList(Splitter.on(",").omitEmptyStrings().split(input)));

    assertEquals(
        Lists.newArrayList("first", "second", "third", "fourth", "", "", "seventh"),
        Lists.newArrayList(Splitter.on(",").trimResults().split(input)));
  }
Пример #28
0
  private List<ServerAddress> mongoHosts() {
    Splitter splitter = Splitter.on(",").omitEmptyStrings().trimResults();
    return ImmutableList.copyOf(
        Iterables.filter(
            Iterables.transform(
                splitter.split(mongoHost),
                new Function<String, ServerAddress>() {

                  @Override
                  public ServerAddress apply(String input) {
                    return new ServerAddress(input, mongoDbPort);
                  }
                }),
            Predicates.notNull()));
  }
Пример #29
0
  /**
   * Setup blocked flag for all builtin UDFs as per udf whitelist and blacklist
   *
   * @param whiteListStr
   * @param blackListStr
   */
  public void setupPermissionsForUDFs(String whiteListStr, String blackListStr) {
    Set<String> whiteList =
        Sets.newHashSet(
            Splitter.on(",").trimResults().omitEmptyStrings().split(whiteListStr.toLowerCase()));
    Set<String> blackList =
        Sets.newHashSet(
            Splitter.on(",").trimResults().omitEmptyStrings().split(blackListStr.toLowerCase()));
    blackList.removeAll(FunctionRegistry.HIVE_OPERATORS);

    for (Map.Entry<String, FunctionInfo> funcEntry : mFunctions.entrySet()) {
      funcEntry
          .getValue()
          .setBlockedFunction(isUdfBlocked(funcEntry.getKey(), whiteList, blackList));
    }
  }
Пример #30
0
  public void save() {
    try {
      if (file.getParentFile() != null) {
        file.getParentFile().mkdirs();
      }

      if (!file.exists() && !file.createNewFile()) {
        return;
      }

      if (file.canWrite()) {
        FileOutputStream fos = new FileOutputStream(file);
        BufferedWriter buffer = new BufferedWriter(new OutputStreamWriter(fos, defaultEncoding));

        buffer.write("# Configuration file\r\n");
        buffer.write("# Generated on " + DateFormat.getInstance().format(new Date()) + "\r\n");
        buffer.write("\r\n");

        for (Map.Entry<String, Map<String, Property>> category : categories.entrySet()) {
          buffer.write("####################\r\n");
          buffer.write("# " + category.getKey() + " \r\n");
          if (customCategoryComments.containsKey(category.getKey())) {
            buffer.write("#===================\r\n");
            String comment = customCategoryComments.get(category.getKey());
            Splitter splitter = Splitter.onPattern("\r?\n");
            for (String commentLine : splitter.split(comment)) {
              buffer.write("# ");
              buffer.write(commentLine + "\r\n");
            }
          }
          buffer.write("####################\r\n\r\n");

          String catKey = category.getKey();
          if (!allowedProperties.matchesAllOf(catKey)) {
            catKey = '"' + catKey + '"';
          }
          buffer.write(catKey + " {\r\n");
          writeProperties(buffer, category.getValue().values());
          buffer.write("}\r\n\r\n");
        }

        buffer.close();
        fos.close();
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }