return repository;
    }

    @Nonnull
    @Override
    public String getId() {
        return repository.getId();
    }

    @Nonnull
    @Override
    public String getType() {
        return repository.getContentType();
    }

    @Nonnull
    @Override
    public String getUrl() {
        return repository.getUrl();
    }

    @Nonnull
    @Override

            if (pos > 0) {
                return value.substring(0, pos);
            }
            if (pos == -1) {
                return value;
            }
            return "localhost";
        }
        if (url.startsWith("file:")) {
            return "localhost";
        }

        return getHost(url);
    }

        return buf;
    }

    protected String getUrl(final Object keyObj) {
        if (keyObj instanceof final UrlQueue<?> urlQueue) {
            return escapeValue(urlQueue.getUrl());
        }
        if (keyObj instanceof final StatsKeyObject statsKey) {
            return escapeValue(statsKey.getUrl());
        }
        if (keyObj instanceof final String key) {
            return escapeValue(key);
        }

        /**
         * @return URL
         */
        public URL getURL() {
            return url_;
        }

        /**
         * @param url
         */
        public void setURL(final URL url) {
            url_ = url;
        }

        /**
         * @return Returns the cal.
         */
        public Calendar getCal() {
            return cal;
        }

        /**

        if (!validateNotNull(problems, fieldName, string, sourceHint)) {
            return false;
        }

        if (!string.isEmpty()) {
            return true;
        }

        addViolation(problems, BuilderProblem.Severity.ERROR, fieldName, sourceHint, "is missing");

        return false;
    }

    /**
     * Asserts:
     * <p/>
     * <ul>

            logger.warn("Failed to get data from {}", accessResult.getUrl(), e);
        }
        return null;
    }

    protected Map<String, Object> ingest(final AccessResult<String> accessResult, final Map<String, Object> map) {
        if (ingestFactory == null) {
            return map;
        }
        Map<String, Object> target = map;
        for (final Ingester ingester : ingestFactory.getIngesters()) {
            try {

        if (p1 == p2) {
            return true;
        }
        // update policy doesn't affect contents
        return p1.isEnabled() == p2.isEnabled() && Objects.equals(p1.getChecksumPolicy(), p2.getChecksumPolicy());
    }

    private static boolean repositoryEquals(RemoteRepository r1, RemoteRepository r2) {
        if (r1 == r2) {
            return true;
        }

        return Objects.equals(r1.getId(), r2.getId())

            wagon.connect(new Repository(repository.getId(), repository.getUrl()), authenticationInfo(repository));

        } else if (repository.getProxy() != null) {
            wagon.connect(new Repository(repository.getId(), repository.getUrl()), proxyInfo(repository));
        } else {
            wagon.connect(new Repository(repository.getId(), repository.getUrl()));
        }
    }

        if (model == null) {
            return null;
        }

        Model.Builder builder = Model.newBuilder(model);
        builder.url(normalize(model.getUrl()));

        Scm scm = model.getScm();
        if (scm != null) {
            builder.scm(Scm.newBuilder(scm)
                    .url(normalize(scm.getUrl()))
                    .connection(normalize(scm.getConnection()))

            return null;
        }

        public String pathOfRemoteRepositoryMetadata(ArtifactMetadata artifactMetadata) {
            return null;
        }

        public String pathOfLocalRepositoryMetadata(ArtifactMetadata metadata, ArtifactRepository repository) {
            return null;
        }

        public String getUrl() {
            return repository.getUrl();