intellij-delegate-to-build.png...

There are two ways to determine the delegate type, depending on the signature of the block method:

 */
public class DelegatingConfiguration implements Configuration {

    private final Configuration delegate;


    /**
     * @param delegate
     *            delegate to pass all non-overridden method calls to
     * 
     */
    public DelegatingConfiguration ( Configuration delegate ) {
        this.delegate = delegate;
    }


    /**
     * {@inheritDoc}
     * 
     * @see jcifs.Configuration#getRandom()

            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

    override fun getProject(): Project =
        delegate.project

    override fun getIsolated(): IsolatedProject =
        delegate.isolated

    override fun dependencies(configureClosure: Closure<*>) =
        delegate.dependencies(configureClosure)

    override fun getPath(): String =
        delegate.path

    override fun getBuildTreePath(): String =

        private final Closure<T> delegate;

        private BuildOperationEmittingClosure(UserCodeApplicationContext.Application application, String registrationPoint, Closure<T> delegate) {
            super(delegate.getOwner(), delegate.getThisObject());
            this.application = application;
            this.delegate = delegate;
            this.registrationPoint = registrationPoint;
        }

	tcs := []struct {
		name string

		delegate         RESTMapper
		resourcePatterns []schema.GroupVersionResource
		result           schema.GroupVersionResource
		err              string
	}{
		{
			name:     "error",
			delegate: fixedRESTMapper{err: errors.New("delegateError")},
			err:      "delegateError",
		},
		{
			name:     "single hit + error",

    final Supplier<T> delegate;

    ThreadSafeSupplier(Supplier<T> delegate) {
      this.delegate = checkNotNull(delegate);
    }

    @Override
    @ParametricNullness
    public T get() {
      synchronized (delegate) {
        return delegate.get();
      }
    }

    @Override
    public String toString() {
      return "Suppliers.synchronizedSupplier(" + delegate + ")";
    }

            this.delegate = delegate;
        }

        @Override
        public Class<?> getParameterType() {
            return delegate.getParameterType();
        }
    }

    private static class BuilderWithNoParameter implements Builder {
        private final String modelName;
        private final ProjectInternal project;
        private final ToolingModelBuilder delegate;