}
		if opts.Limit > 0 && objsReturned >= opts.Limit {
			return nil
		}

		// Skip forward, if requested...
		sb := bytebufferpool.Get()
		defer func() {
			sb.Reset()
			bytebufferpool.Put(sb)
		}()

		forward := ""
		if len(opts.ForwardTo) > 0 && strings.HasPrefix(opts.ForwardTo, current) {
			forward = strings.TrimPrefix(opts.ForwardTo, current)
			// Trim further directories and trailing slash.

 * the <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>Warning:</b> The methods of {@code ForwardingSortedMultiset} forward
 * <b>indiscriminately</b> to the methods of the delegate. For example, overriding {@link
 * #add(Object, int)} alone <b>will not</b> change the behavior of {@link #add(Object)}, which can

  private static final class InverseSerializedForm<K, V> implements Serializable {
    private final ImmutableBiMap<K, V> forward;

    InverseSerializedForm(ImmutableBiMap<K, V> forward) {
      this.forward = forward;
    }

    Object readResolve() {
      return forward.inverse();
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 1;
  }

   * this implementation.
   *
   * @since 7.0
   */
  protected boolean standardEquals(@Nullable Object object) {
    return Sets.equalsImpl(this, object);
  }

  /**
   * A sensible definition of {@link #hashCode} in terms of {@link #iterator}. If you override
   * {@link #iterator}, you may wish to override {@link #equals} to forward to this implementation.
   *
   * @since 7.0

  }

  public void testFrom() {
    Function<String, Integer> forward = Integer::parseInt;
    Function<Object, String> backward = toStringFunction();

    Converter<String, Number> converter = Converter.<String, Number>from(forward, backward);

    assertThat(converter.convert(null)).isNull();
    assertThat(converter.reverse().convert(null)).isNull();

    private final NavigableSet<E> forward;

    DescendingSet(NavigableSet<E> forward) {
      this.forward = forward;
    }

    @Override
    protected NavigableSet<E> delegate() {
      return forward;
    }

    @Override
    public @Nullable E lower(@ParametricNullness E e) {
      return forward.higher(e);
    }

    @Override

 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>Warning:</b> The methods of {@code ForwardingMapEntry} forward <i>indiscriminately</i> to
 * the methods of the delegate. For example, overriding {@link #getValue} alone <i>will not</i>
 * change the behavior of {@link #equals}, which can lead to unexpected behavior. In this case, you

            Currency.FRANC, Country.SWITZERLAND);
    EnumBiMap<Currency, Country> bimap = EnumBiMap.create(map);

    // forward map ordered by currency
    assertThat(bimap.keySet())
        .containsExactly(Currency.DOLLAR, Currency.FRANC, Currency.PESO)
        .inOrder();
    // forward map ordered by currency (even for country values)
    assertThat(bimap.values())

 * to the methods of the delegate. For example, overriding {@link #get(long, TimeUnit)} alone
 * <b>will not</b> change the behavior of {@link #get()}, which can lead to unexpected behavior. In
 * this case, you should override {@code get()} as well.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code

 * <p><b>Warning:</b> The methods of {@code ForwardingDeque} forward <b>indiscriminately</b> to the
 * methods of the delegate. For example, overriding {@link #add} alone <b>will not</b> change the
 * behavior of {@link #offer} which can lead to unexpected behavior. In this case, you should
 * override {@code offer} as well.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code