private final Lock delegate;

    @SuppressWarnings("unused")
    private final WeakSafeReadWriteLock strongReference;

    WeakSafeLock(Lock delegate, WeakSafeReadWriteLock strongReference) {
      this.delegate = delegate;
      this.strongReference = strongReference;
    }

    @Override
    Lock delegate() {
      return delegate;
    }

    @Override

    private final TestMultisetGenerator<E> delegate;

    ForwardingTestMultisetGenerator(TestMultisetGenerator<E> delegate) {
      this.delegate = delegate;
    }

    @Override
    public SampleElements<E> samples() {
      return delegate.samples();
    }

    @Override
    public E[] createArray(int length) {
      return delegate.createArray(length);
    }

    @Override

            ArtifactDescriptorReaderDelegate delegate =
                    (ArtifactDescriptorReaderDelegate) config.get(ArtifactDescriptorReaderDelegate.class.getName());

            if (delegate == null) {
                delegate = this.delegate;
            }

            delegate.populateResult(session, result, model);
        }

        return result;
    }

    private final MetadataStaxReader delegate;

    /**
     * Default constructor
     */
    public MetadataXpp3Reader() {
        delegate = new MetadataStaxReader();
    }

    /**
     * Constructor with ContentTransformer
     *
     * @param contentTransformer a transformer
     */
    public MetadataXpp3Reader(ContentTransformer contentTransformer) {

final class SingletonImmutableList<E> extends ForwardingImmutableList<E> {

  final transient List<E> delegate;
  // This reference is used both by the custom field serializer, and by the
  // GWT compiler to infer the elements of the lists that needs to be
  // serialized.
  E element;

  SingletonImmutableList(E element) {
    this.delegate = singletonList(checkNotNull(element));
    this.element = element;
  }

  @Override

    return ImmutableMultimap.<String, Integer>of().asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    Multimap<String, Integer> delegate = HashMultimap.create();
    populate(delegate);
    return ImmutableMultimap.copyOf(delegate).asMap();
  }

        .asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    ListMultimap<String, Integer> delegate = ArrayListMultimap.create();
    populate(delegate);
    return Multimaps.transformValues(delegate, Functions.<Integer>identity()).asMap();
  }

class DirFileEntryAdapterIterator extends FileEntryAdapterIterator {

    /**
     * @param parent
     * @param delegate
     * @param filter
     */
    public DirFileEntryAdapterIterator ( SmbResource parent, CloseableIterator<FileEntry> delegate, ResourceFilter filter ) {
        super(parent, delegate, filter);
    }


    /**
     * @param fe
     * @return
     * @throws MalformedURLException
     */

              public ListIterator<?> apply(ListIterator delegate) {
                return wrap((ListIterator<?>) delegate);
              }
            });
  }

  private static <T> ListIterator<T> wrap(final ListIterator<T> delegate) {
    return new ForwardingListIterator<T>() {
      @Override
      protected ListIterator<T> delegate() {
        return delegate;
      }
    };
  }

 *
 * Callers should prefer to use [okhttp3.java.net.cookiejar.JavaNetCookieJar] directly.
 */
class JavaNetCookieJar private constructor(
  delegate: okhttp3.java.net.cookiejar.JavaNetCookieJar,
) : CookieJar by delegate {
  constructor(cookieHandler: CookieHandler) : this(
    okhttp3.java.net.cookiejar.JavaNetCookieJar(
      cookieHandler,
    ),
  )