}

    public void merge(ArtifactRepositoryPolicy policy) {
        if (policy != null && policy.isEnabled()) {
            setEnabled(true);

            if (ordinalOfCksumPolicy(policy.getChecksumPolicy()) < ordinalOfCksumPolicy(getChecksumPolicy())) {
                setChecksumPolicy(policy.getChecksumPolicy());
            }

            if (ordinalOfUpdatePolicy(policy.getUpdatePolicy()) < ordinalOfUpdatePolicy(getUpdatePolicy())) {

    private int getPolicy(RepositorySystemSession session, Artifact a, ArtifactDescriptorRequest request) {
        ArtifactDescriptorPolicy policy = session.getArtifactDescriptorPolicy();
        if (policy == null) {
            return ArtifactDescriptorPolicy.STRICT;
        }
        return policy.getPolicy(session, new ArtifactDescriptorPolicyRequest(a, request.getRequestContext()));
    }

            throws TransferFailedException, ResourceDoesNotExistException {
        String remotePath = repository.pathOf(artifact);

        ArtifactRepositoryPolicy policy = artifact.isSnapshot() ? repository.getSnapshots() : repository.getReleases();

        if (!policy.isEnabled()) {
            logger.debug(
                    "Skipping disabled repository " + repository.getId() + " for resolution of " + artifact.getId());

            return null;
        }

        public void setSnapshotUpdatePolicy(ArtifactRepositoryPolicy policy) {}

        public ArtifactRepositoryPolicy getReleases() {
            return null;
        }

        public void setReleaseUpdatePolicy(ArtifactRepositoryPolicy policy) {}

        public ArtifactRepositoryLayout getLayout() {
            return null;
        }

     */
    @Nonnull
    Optional<Boolean> cacheArtifactNotFound();

    /**
     * Indicates whether Maven should use strict artifact descriptor policy.
     *
     * @return an {@link Optional} containing true if strict artifact descriptor policy should be used, false if not, or empty if not specified
     */
    @Nonnull
    Optional<Boolean> strictArtifactDescriptorPolicy();

    /**

                }
            }
            return "";
        }
    }

    private static RepositoryPolicy toPolicy(ArtifactRepositoryPolicy policy) {
        RepositoryPolicy result = null;
        if (policy != null) {
            result = new RepositoryPolicy(policy.isEnabled(), policy.getUpdatePolicy(), policy.getChecksumPolicy());
        }
        return result;
    }

        boolean enabled = true;
        String checksums = toRepositoryChecksumPolicy(RepositoryPolicy.CHECKSUM_POLICY_WARN); // the default
        String updates = RepositoryPolicy.UPDATE_POLICY_DAILY;

        if (policy != null) {
            enabled = policy.isEnabled();
            if (policy.getUpdatePolicy() != null) {

/**
 * Default conflict resolver.Implements closer newer first policy by default, but could be configured via plexus
 *
 */
@Named
@Singleton
@Deprecated
public class DefaultGraphConflictResolver implements GraphConflictResolver {
    /**
     * artifact, closer to the entry point, is selected
     */
    @Inject
    protected GraphConflictResolutionPolicy policy;

                ArtifactRepositoryPolicy policy = metadata.getPolicy(repository);

                File file =
                        new File(localRepo.getBasedir(), localRepo.pathOfLocalRepositoryMetadata(metadata, repository));
                boolean update;

                if (!policy.isEnabled()) {
                    update = false;

        if ((nature & RepositoryMetadata.RELEASE_OR_SNAPSHOT) == RepositoryMetadata.RELEASE_OR_SNAPSHOT) {
            ArtifactRepositoryPolicy policy = new ArtifactRepositoryPolicy(repository.getReleases());
            policy.merge(repository.getSnapshots());
            return policy;
        } else if ((nature & RepositoryMetadata.SNAPSHOT) != 0) {
            return repository.getSnapshots();
        } else {