/**
     * Creates a new map instance whose keys are Class instances. Keys are referenced using strong or weak references, values by strong or other references depending on their usage.
     * This allows the classes to be collected.
     *
     * <p>A map differs from a cache in that entries are not discarded based on memory pressure, but are discarded only when the key is collected.

            return null;
        }
    }

    public static String toLongIdHexString(long key) {
        return String.format("%016X", key).trim();
    }

    public static String toHexString(byte[] fingerprint) {
        return Fingerprint.wrap(fingerprint).toString();
    }

     *
     * @param key the key
     * @param value the value
     */
    void put(K key, V value);

    /**
     * Adds a map entry to the property value.
     *
     * <p>The given provider will be queried when the value of this property is queried.
     * This property will have no value when the given provider has no value.
     *
     * @param key the key

    void put(K key, V value) {
        map.put(new WeakKey<>(key), value);
    }

    @Nullable
    V get(K key) {
        return map.get(new WeakKey<>(key));
    }

    Set<WeakKey<K>> keySet() {
        return map.keySet();
    }

    V computeIfAbsent(K key, AbsentValueProvider<V> absentValueProvider) {
        WeakKey<K> weakKey = new WeakKey<>(key);
        V value = map.get(weakKey);

 * and for strong class references not to be held for the cache keys.
 * <p>
 * The use of {@link WeakClassSet} as the cache key, opposed to just {@link Class}, is because a type may be composed of types from different classloaders.
 * An example of this would be something like {@code ModelSet<SomeCustomUserType>}.
 * The class set abstraction effectively creates a key for all classes involved in a type.

    }

    @Override
    public boolean isFatal() {
        return false;
    }

    @Override
    public void explainTo(TreeFormatter formatter) {
        formatter.append("artifact was signed but all keys were ignored");
    }

                } catch (MissingPropertyException e) {
                    throw new GradleException(String.format("Missing property (%s) for Groovy template expansion. Defined keys %s.", e.getProperty(), properties.keySet()), e);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }
        });
    }

public abstract class DefaultKeyServers {
    private final static List<URI> DEFAULT_KEYSERVERS = ImmutableList.of(
        uri("hkp://ha.pool.sks-keyservers.net"),
        uri("https://keyserver.ubuntu.com"),
        uri("https://keys.openpgp.org"),
        uri("https://pgp.mit.edu")
    );

    private static URI uri(String uri) {
        try {
            return new URI(uri);
        } catch (URISyntaxException e) {

            missingKeys.removeAll(toStringList(properties.keySet()));
            if (!missingKeys.isEmpty()) {
                throw new IncompleteInputException("Input configuration map does not contain following mandatory keys: " + missingKeys, missingKeys);
            }
        }
        return configureByMapInternal(properties, delegate);
    }

    /**
     * Incomplete input exception.
     */
    @Deprecated

            if (keyId == null) {
                PGPSecretKey key = new JcaPGPSecretKeyRing(in).getSecretKey();
                return factory.createSignatory(name, key, password);
            } else {
                PgpKeyId expectedKeyId = new PgpKeyId(keyId);
                for (PGPSecretKeyRing keyring : new JcaPGPSecretKeyRingCollection(in)) {
                    for (PGPSecretKey key : keyring) {