예제 #1
0
  /**
   * Returns results from parsing a {@link java.net.URI} with this pattern. If the URI doesn't match
   * the pattern, this will return null.
   *
   * @param uri A URI to match against this URIPattern
   * @return A Map of the pattern's variable names to values from the parsed URI
   */
  public Map<String, String> getMatch(URI uri) {
    // verify that the schemes match
    if (pattern.isAbsolute()) {
      // if there should be a scheme, make sure it matches
      if (!pattern.getScheme().equalsIgnoreCase(uri.getScheme())) {
        return null;
      }
    } else if (uri.getScheme() != null) {
      return null;
    }

    Map<String, String> result = Maps.newLinkedHashMap(defaults);

    if (pattern.isOpaque()) {
      if (!uri.isOpaque()) {
        return null;
      }

      Iterator<String> pathQuery =
          PATH_QUERY_SPLITTER.split(uri.getRawSchemeSpecificPart()).iterator();

      if (!addPath(patternPath, Iterators.getNext(pathQuery, null), result)) {
        return null;
      }

      addQuery(Iterators.getNext(pathQuery, null), result);

    } else if (!uri.isOpaque()) {
      addAuthority(uri, result);

      if (patternPath.isEmpty() && !uri.getRawPath().isEmpty()) {
        return null;
      }

      if (!addPath(patternPath, uri.getRawPath(), result)) {
        return null;
      }

      addQuery(uri.getRawQuery(), result);

    } else {
      return null;
    }

    if (!addComplexMatch(pattern.getFragment(), uri.getFragment(), result)) {
      return null;
    }

    // save this match
    this.lastMatch = result;

    // return the new result, so that this is thread-safe
    return result;
  }
예제 #2
0
  public URIPattern(URI uri) {
    this.pattern = uri;

    Map<String, String> accumulator = Maps.newHashMap();
    if (pattern.isOpaque()) {
      Iterator<String> pathQuery =
          PATH_QUERY_SPLITTER.split(pattern.getSchemeSpecificPart()).iterator();
      this.patternPath = Iterators.getNext(pathQuery, null);
      addQuery(Iterators.getNext(pathQuery, null), accumulator);
    } else {
      patternPath = pattern.getRawPath();
      addQuery(pattern.getRawQuery(), accumulator);
      addAuthority(pattern, accumulator);
    }
    if (pattern.getScheme() != null) {
      accumulator.put(SCHEME, pattern.getScheme());
    }
    this.defaults = ImmutableMap.copyOf(accumulator);
  }
예제 #3
0
  @Override
  public int run() throws IOException {
    if (datasets == null || datasets.size() != 1) {
      throw new IllegalArgumentException("Exactly one dataset name must be specified.");
    }

    String dataset = datasets.remove(0);
    Dataset<GenericRecord> currentDataset = load(dataset).getDataset();

    DatasetDescriptor.Builder descriptorBuilder =
        new DatasetDescriptor.Builder(currentDataset.getDescriptor());

    if (avroSchemaFile != null) {
      descriptorBuilder.schemaUri(qualifiedURI(avroSchemaFile));
    }

    if (partitionStrategyFile != null) {
      descriptorBuilder.partitionStrategyUri(qualifiedURI(partitionStrategyFile));
    }

    if (properties != null) {
      for (String propValue : properties) {
        Iterator<String> parts = PROP_VALUE_SEP.split(propValue).iterator();
        descriptorBuilder.property(Iterators.getNext(parts, null), Iterators.getNext(parts, null));
      }
    }

    DatasetDescriptor descriptor = descriptorBuilder.build();

    if (isDatasetOrViewUri(dataset)) {
      Datasets.<GenericData.Record, Dataset<GenericData.Record>>update(
          dataset, descriptor, GenericData.Record.class);
    } else {
      getDatasetRepository().update(namespace, dataset, descriptor);
    }

    console.debug("Updated {}", dataset);

    return 0;
  }
예제 #4
0
 /**
  * Returns the element at the specified position in an iterable or a default value otherwise.
  *
  * @param position position of the element to return
  * @param defaultValue the default value to return if {@code position} is greater than or equal to
  *     the size of the iterable
  * @return the element at the specified position in {@code iterable} or {@code defaultValue} if
  *     {@code iterable} contains fewer than {@code position + 1} elements.
  * @throws IndexOutOfBoundsException if {@code position} is negative
  * @since 4.0
  */
 @Nullable
 public static <T> T get(Iterable<? extends T> iterable, int position, @Nullable T defaultValue) {
   checkNotNull(iterable);
   Iterators.checkNonnegative(position);
   if (iterable instanceof List) {
     List<? extends T> list = Lists.cast(iterable);
     return (position < list.size()) ? list.get(position) : defaultValue;
   } else {
     Iterator<? extends T> iterator = iterable.iterator();
     Iterators.advance(iterator, position);
     return Iterators.getNext(iterator, defaultValue);
   }
 }
예제 #5
0
 @GwtIncompatible("NavigableSet")
 public Object floor(Object paramObject)
 {
   return Iterators.getNext(headSet(paramObject, true).descendingIterator(), null);
 }
예제 #6
0
 /**
  * A sensible definition of {@link #ceiling} in terms of the {@code iterator} method of {@link
  * #tailSet(Object, boolean)}. If you override {@link #tailSet(Object, boolean)}, you may wish to
  * override {@link #ceiling} to forward to this implementation.
  */
 protected E standardCeiling(E e) {
   return Iterators.getNext(tailSet(e, true).iterator(), null);
 }
예제 #7
0
 /**
  * A sensible definition of {@link #floor} in terms of the {@code descendingIterator} method of
  * {@link #headSet(Object, boolean)}. If you override {@link #headSet(Object, boolean)}, you may
  * wish to override {@link #floor} to forward to this implementation.
  */
 protected E standardFloor(E e) {
   return Iterators.getNext(headSet(e, true).descendingIterator(), null);
 }
예제 #8
0
 /**
  * A sensible definition of {@link #lower} in terms of the {@code descendingIterator} method of
  * {@link #headSet(Object, boolean)}. If you override {@link #headSet(Object, boolean)}, you may
  * wish to override {@link #lower} to forward to this implementation.
  */
 protected E standardLower(E e) {
   return Iterators.getNext(headSet(e, false).descendingIterator(), null);
 }
예제 #9
0
 /**
  * A sensible definition of {@link #higher} in terms of the {@code iterator} method of {@link
  * #tailSet(Object, boolean)}. If you override {@link #tailSet(Object, boolean)}, you may wish to
  * override {@link #higher} to forward to this implementation.
  */
 protected E standardHigher(E e) {
   return Iterators.getNext(tailSet(e, false).iterator(), null);
 }
 /**
  * Remove a resource request and return it.
  *
  * @return The {@link Resource} and {@link Collection} of {@link RuntimeSpecification} or {@code
  *     null} if there is no more request.
  */
 Map.Entry<Resource, ? extends Collection<RuntimeSpecification>> takeRequest() {
   Map.Entry<Resource, Collection<RuntimeSpecification>> next = Iterators.getNext(requests, null);
   return next == null
       ? null
       : Maps.immutableEntry(next.getKey(), ImmutableList.copyOf(next.getValue()));
 }
예제 #11
0
 /**
  * Returns the first element in {@code iterable} or {@code defaultValue} if the iterable is empty.
  * The {@link Iterators} analog to this method is {@link Iterators#getNext}.
  *
  * <p>If no default value is desired (and the caller instead wants a {@link
  * NoSuchElementException} to be thrown), it is recommended that {@code
  * iterable.iterator().next()} is used instead.
  *
  * @param defaultValue the default value to return if the iterable is empty
  * @return the first element of {@code iterable} or the default value
  * @since 7.0
  */
 @Nullable
 public static <T> T getFirst(Iterable<? extends T> iterable, @Nullable T defaultValue) {
   return Iterators.getNext(iterable.iterator(), defaultValue);
 }