return delegate.buildFile
        }

        override fun getDisplayName(): String {
            return delegate.displayName
        }

        override fun getDescription(): String? {
            onAccess("description")
            return delegate.description
        }

        override fun setDescription(description: String?) {
            onAccess("description")

        private final Map.Entry<Object, Object> delegate;

        TrackingEntry(Map.Entry<Object, Object> delegate) {
            this.delegate = delegate;
        }

        @Override
        public Object getKey() {
            return delegate.getKey();
        }

        @Override
        public Object getValue() {
            return delegate.getValue();
        }

        @Override

            delegate = securityHandler
            delegate.server = handlers.server
            if (shouldRestart) {
                delegate.start()
            }
        }
    }

    @Override
    void start() throws Exception {
        delegate.start()
    }

    @Override
    void stop() throws Exception {
        delegate.stop()
    }

    @Override

    private final Optional<T> delegate;

    private ExtendedOptional(Optional<T> delegate) {
        this.delegate = delegate;
    }

    public static <T> ExtendedOptional<T> extend(Optional<T> delegate) {
        return new ExtendedOptional<>(delegate);
    }

    @SuppressWarnings("OptionalGetWithoutIsPresent")
    public T get() {
        return delegate.get();
    }

    public boolean isPresent() {

      implements Serializable {
    final Object delegate;

    DelegatingInvocationHandler(Object delegate) {
      this.delegate = checkNotNull(delegate);
    }

    @Override
    protected Object handleInvocation(Object proxy, Method method, Object[] args) throws Throwable {
      return method.invoke(delegate, args);
    }

    @Override
    public String toString() {

  final transient Map<K, V> delegate;

  ForwardingImmutableMap(Map<? extends K, ? extends V> delegate) {
    this.delegate = Collections.unmodifiableMap(delegate);
  }

  @SuppressWarnings("unchecked")
  ForwardingImmutableMap(boolean throwIfDuplicateKeys, Entry<? extends K, ? extends V>... entries) {
    Map<K, V> delegate = Maps.newLinkedHashMap();

import okio.BufferedSource

open class ForwardingResponseBody(delegate: ResponseBody?) : ResponseBody() {
  private val delegate: ResponseBody

  fun delegate(): ResponseBody {
    return delegate
  }

  override fun contentType(): MediaType? {
    return delegate.contentType()
  }

  override fun contentLength(): Long {
    return delegate.contentLength()
  }

  override fun source(): BufferedSource {

    private AttributeContainerInternal delegate;

    public FreezableAttributeContainer(AttributeContainerInternal delegate, Describable owner) {
        this.delegate = delegate;
        this.owner = owner;
    }

    /**
     * Prevent further mutations to this attribute container.
     */
    public void freeze() {
        this.delegate = delegate.asImmutable();
    }

    @Override

      this.delegate = Preconditions.checkNotNull(delegate);
    }

    @Override
    protected final Cache<K, V> delegate() {
      return delegate;
    }
  }

  final transient Collection<E> delegate;

  ForwardingImmutableCollection(Collection<E> delegate) {
    this.delegate = delegate;
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return Iterators.unmodifiableIterator(delegate.iterator());
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return object != null && delegate.contains(object);
  }

  @Override