final ListenableFuture<? extends V> delegate;

    SetFuture(ListenableFuture<? extends V> delegate) {
      this.delegate = delegate;
    }

    @Override
    public void run() {
      if (isCancelled()) {
        return;
      }

      if (delegate instanceof AbstractFuture) {
        AbstractFuture<? extends V> other = (AbstractFuture<? extends V>) delegate;
        value = other.value;

        private final PublicKeyResultBuilder delegate;
        public boolean hasResult;

        private FirstMatchBuilder(PublicKeyResultBuilder delegate) {
            this.delegate = delegate;
        }

        @Override
        public void keyRing(PGPPublicKeyRing keyring) {
            delegate.keyRing(keyring);
            hasResult = true;
        }

        @Override

            delegates.put(delegate.getId(), delegate);
            for (TestMethodResult result : delegate.getResults()) {
                add(result);
            }
            if (delegate.getStartTime() < getStartTime()) {
                setStartTime(delegate.getStartTime());
            }
        }
    }

    @Override

Lior Lieberman <******@****.***> 1707338903 +0000

Laura Kassovic <******@****.***> 1701107622 -0800

 * `getValue` operator based on the static type of the delegate.
 */
class ExistingDomainObjectDelegate<T>
private constructor(
    internal val delegate: T
) {
    companion object {
        fun <T> of(delegate: T) =
            ExistingDomainObjectDelegate(delegate)
    }
}


/**
 * Gets the delegate value.
 */

/**
 * A cookie jar that delegates to a [java.net.CookieHandler].
 *
 * This implementation delegates everything to [okhttp3.java.net.cookiejar.JavaNetCookieJar], which
 * conforms to the package-naming limitations of JPMS.
 *
 * Callers should prefer to use [okhttp3.java.net.cookiejar.JavaNetCookieJar] directly.
 */
class JavaNetCookieJar private constructor(
  delegate: okhttp3.java.net.cookiejar.JavaNetCookieJar,

    }

    internal
    abstract val delegate: ScriptHandler

    override fun getSourceFile(): File? =
        delegate.sourceFile

    override fun getSourceURI(): URI? =
        delegate.sourceURI

    override fun getRepositories(): RepositoryHandler =
        delegate.repositories

    override fun repositories(configureClosure: Closure<Any>) =
        delegate.repositories(configureClosure)

        1 * lockingState.lockedDependencies >> [DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId('org', 'foo'), '1.0')]
        1 * delegate.resolveGraph(resolveContext) >> delegateResults
        results == delegateResults
    }

    def "delegates to backing service to resolve build dependencies when there are one or more dependencies"() {
        given:
        ResolverResults delegateResults = Mock()

/** An [SSLSession] that delegates all calls.  */
abstract class DelegatingSSLSession(protected val delegate: SSLSession?) : SSLSession {
  override fun getId(): ByteArray {
    return delegate!!.id
  }

  override fun getSessionContext(): SSLSessionContext {
    return delegate!!.sessionContext
  }

  override fun getCreationTime(): Long {
    return delegate!!.creationTime
  }