| HttpUrl.get(URL)                    | URL.toHttpUrlOrNull()           |
| HttpUrl.parse(String)               | String.toHttpUrlOrNull()        |
| HttpUrl.uri()                       | HttpUrl.toUri()                 |
| HttpUrl.url()                       | HttpUrl.toUrl()                 |
| MediaType.get(String)               | String.toMediaType()            |

         * @param file the file path
         * @return the extracted document ID
         */
        protected String getDocId(final Path file) {
            final String s = file.toUri().toString();
            final String b = basePath.toUri().toString();
            final String id = s.replace(b, StringUtil.EMPTY).replace("." + imageExtention, StringUtil.EMPTY).replace("/", StringUtil.EMPTY);
            if (logger.isDebugEnabled()) {

      // If the user specifies a proxy, try that and only that.
      if (proxy != null) return listOf(proxy)

      // If the URI lacks a host (as in "http://</"), don't call the ProxySelector.
      val uri = url.toUri()
      if (uri.host == null) return immutableListOf(Proxy.NO_PROXY)

      // Try each of the ProxySelector choices until one connection succeeds.
      val proxiesOrNull = address.proxySelector.select(uri)

            if (logger.isDebugEnabled()) {
                String id = getId(constituent);
                logger.debug("  Included: {}", id);
            }

            try {
                classRealm.addURL(file.toURI().toURL());
            } catch (MalformedURLException e) {
                // Not going to happen
                logger.error(e.getMessage(), e);
            }
        }
    }

                        }
                        for (final File f : files) {
                            final String childUri = f.toURI().toASCIIString();
                            requestDataSet.add(RequestDataBuilder.newRequestData().get().url(childUri).build());
                        }
                    } else {

        return tasksExecuted + if (descriptor.language === Language.KOTLIN) 1 else 0
    }

    private
    fun Directory.template(templateFragment: String) = file("$templateFragment.template").asFile.toURI().toURL()

        policy.setUpdatePolicy("always");

        Repository repository = new Repository();
        repository.setId(MavenRepositorySystem.DEFAULT_REMOTE_REPO_ID);
        repository.setUrl("file://" + repoDir.toURI().getPath());
        repository.setReleases(policy);
        repository.setSnapshots(policy);

        return Arrays.asList(mavenRepositorySystem.buildArtifactRepository(repository));
    }

                logger.debug("Loading resource: url={}", resource);
                final URI resourceUri;
                try {
                    resourceUri = resource.toURI();
                } catch (final URISyntaxException e) {
                    logger.warn("Invalid URI for resource: url={}", resource, e);
                    continue;
                }

                log.debug("  Excluded {}", id);
            } else {
                File file = artifact.getFile();
                log.debug("  Included {} located at {}", id, file);
                realm.addURL(file.toURI().toURL());
            }
        }
        return CoreExtensionEntry.discoverFrom(
                realm,
                Collections.singleton(artifacts.get(0).getFile()),

        if (repositoryLayout instanceof ArtifactRepositoryLayout2 artifactRepositoryLayout2) {
            repository = artifactRepositoryLayout2.newMavenArtifactRepository(
                    id, path.toUri().toString(), snapshots, releases);
        } else {
            repository = new MavenArtifactRepository(id, path, repositoryLayout, snapshots, releases);
        }

        return repository;
    }