import javax.annotation.Nullable;
import java.io.File;

public class BuildTreeDefinedKeys {
    private static final String VERIFICATION_KEYRING_GPG = "verification-keyring.gpg";
    private static final String VERIFICATION_KEYRING_ASCII = "verification-keyring.keys";

    private final KeyringFilePublicKeyService keyService;
    private final File keyringsRoot;

    private final File effectiveKeyringsFile;

	return b
}

// WithKeyring sets the Keyring field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Keyring field is set to the value of the last call.
func (b *RBDVolumeSourceApplyConfiguration) WithKeyring(value string) *RBDVolumeSourceApplyConfiguration {
	b.Keyring = &value
	return b
}

    }

    /**
     * Returns the number of keys in the given keyring.
     * There is no public API to do this, so we use reflection to access the private field.
     * Public keys iterator is not used because it would require O(n) time to count the keys.
     */
    @SuppressWarnings("unchecked")
    public static int getSize(PGPPublicKeyRing keyring) {
        try {

            throw new RuntimeException(e);
        }
    }

    public static PGPPublicKeyRing strip(PGPPublicKeyRing keyring, KeyFingerPrintCalculator fingerprintCalculator) {
        List<PGPPublicKey> strippedKeys = StreamSupport
            .stream(keyring.spliterator(), false)
            .map(key -> stripKey(key, fingerprintCalculator))
            .collect(Collectors.toList());

 */
package org.gradle.security.internal;

import org.bouncycastle.openpgp.PGPPublicKey;
import org.bouncycastle.openpgp.PGPPublicKeyRing;

public interface PublicKeyResultBuilder {
    void keyRing(PGPPublicKeyRing keyring);
    void publicKey(PGPPublicKey publicKey);

        keyService.findByFingerprint(key.getFingerprint(), new PublicKeyResultBuilder() {
            @Override
            public void keyRing(PGPPublicKeyRing keyring) {
                Set<String> userIds = new TreeSet<>();
                collectUserIds(userIds, key);
                keyring.getPublicKeys().forEachRemaining(userkey -> collectUserIds(userIds, userkey));
                if (!userIds.isEmpty()) {

    public PgpSignatory getSignatory(String name) {
        return signatories.get(name);
    }

    public PgpSignatory createSignatory(String name, String keyId, File keyRing, String password) {
        return signatories.put(name, factory.createSignatory(name, keyId, keyRing, password));
    }

    public PgpSignatory createSignatory(Project project, String name, boolean required) {

        switch (args.length) {
            case 3:
                String keyId = args[0].toString();
                File keyRing = project.file(args[1].toString());
                String password = args[2].toString();
                createSignatory(name, keyId, keyRing, password);
                break;
            case 0:
                createSignatory(project, name, true);
                break;

		machineInfo:            machineInfo,
		osInterface:            osInterface,
		runtimeHelper:          runtimeHelper,
		runtimeService:         runtimeService,
		imageService:           imageService,
		keyring:                keyring,
		seccompProfileRoot:     fakeSeccompProfileRoot,
		internalLifecycle:      cm.NewFakeInternalContainerLifecycle(),
		logReduction:           logreduction.NewLogReduction(identicalErrorDelay),

                keyService.findByLongId(pgpSignature.getKeyID(), new PublicKeyResultBuilder() {
                    @Override
                    public void keyRing(PGPPublicKeyRing keyring) {

                    }

                    @Override
                    public void publicKey(PGPPublicKey pgpPublicKey) {
                        missing.set(false);