interpolationTargets.add(target);

            this.modelInterpolator = modelInterpolator;
            this.logger = logger;
        }

        public ModelInterpolationException run() {
            while (!interpolationTargets.isEmpty()) {
                Object obj = interpolationTargets.removeFirst();

                try {
                    traverseObjectWithParents(obj.getClass(), obj);

 *
 * @since 4.0.0
 * @see DependencyResolver#resolve(DependencyResolverRequest)
 */
@Experimental
public interface DependencyResolverResult {

    /**
     * Gets the exceptions that occurred while building the dependency graph.
     *
     * @return the exceptions that occurred, never {@code null}
     */
    @Nonnull
    List<Exception> getExceptions();

    /**

				return n, cr.err
			}
			break
		}

		// Manually deserialize the size since AWS specified
		// the chunk size to be of variable width. In particular,
		// a size of 16 is encoded as `10` while a size of 64 KB
		// is `10000`.
		switch {
		case b >= '0' && b <= '9':
			size = size<<4 | int(b-'0')
		case b >= 'a' && b <= 'f':
			size = size<<4 | int(b-('a'-10))
		case b >= 'A' && b <= 'F':

   * @since 11.0
   */
  @ParametricNullness
  public <E extends T> E min(Iterator<E> iterator) {
    // let this throw NoSuchElementException as necessary
    E minSoFar = iterator.next();

    while (iterator.hasNext()) {
      minSoFar = this.<E>min(minSoFar, iterator.next());
    }

    return minSoFar;
  }

  /**

   * at all are provided (an empty list), the resulting Cartesian product has one element, an empty
   * list (counter-intuitive, but mathematically consistent).
   *
   * <p><i>Performance notes:</i> while the cartesian product of lists of size {@code m, n, p} is a
   * list of size {@code m x n x p}, its actual memory consumption is much smaller. When the

    checkNotNull(comparator);
    if (!elements.hasNext()) {
      return emptySet(comparator);
    }
    SortedSet<E> delegate = new TreeSet<E>(comparator);
    while (elements.hasNext()) {
      E element = elements.next();
      checkNotNull(element);
      delegate.add(element);
    }
    return new RegularImmutableSortedSet<E>(delegate, false);
  }

      File file = getFile();
      InputStream in = new FileInputStream(file);
      ByteArrayOutputStream out = new ByteArrayOutputStream();
      byte[] buffer = new byte[100];
      int read;
      while ((read = in.read(buffer)) != -1) {
        out.write(buffer, 0, read);
      }
      return out.toByteArray();
    }
  }

                this.resolverOrder.add(ResolverType.RESOLVER_BCAST);
            }
        }
        else {
            StringTokenizer st = new StringTokenizer(ro, ",");
            while ( st.hasMoreTokens() ) {
                String s = st.nextToken().trim();
                if ( s.equalsIgnoreCase("LMHOSTS") ) {
                    this.resolverOrder.add(ResolverType.RESOLVER_LMHOSTS);
                }

And Swagger UI has supported this particular `examples` field for a while. So, you can use it to **show** different **examples in the docs UI**.

        }
        if (!rangeValue.closed) {
            return isLeft ? -1 : 1;
        }
        return 0;
    }

    private static void addZeroTokens(List<String> tokens, int max) {
        while (tokens.size() < max) {
            tokens.add("0");
        }
    }

    private static boolean isRange(String value) {
        return value.startsWith("[") || value.startsWith("(");
    }