return Collections.emptyList();
            }
        };
        ComponentUtil.register(webAuthenticationService, WebAuthenticationService.class.getCanonicalName());
        RequestHeaderService requestHeaderService = new RequestHeaderService() {
            @Override
            public List<RequestHeader> getRequestHeaderList(final String webConfigId) {

            long lhs = 0;
            for (Class<?> paramType : o1.getParameterTypes()) {
                lhs += paramType.getCanonicalName().hashCode();
            }
            long rhs=0;
            for (Class<?> paramType : o2.getParameterTypes()) {
                rhs += paramType.getCanonicalName().hashCode();
            }
            return Long.compare(lhs, rhs);
        }
        return parameterSort;
    }

        for (KnownArchitecture knownArchitecture : KNOWN_ARCHITECTURES) {
            if (knownArchitecture.isAlias(input.toLowerCase())) {
                return new DefaultArchitecture(knownArchitecture.getCanonicalName());
            }
        }
        return new DefaultArchitecture(input);
    }

    public static ArchitectureInternal of(KnownArchitecture architecture) {

        Args.check(credentials instanceof HttpClientHttpHeaderCredentials, "Only " + HttpClientHttpHeaderCredentials.class.getCanonicalName() + " supported for AuthScheme " + this.getClass().getCanonicalName() + ", got " + credentials.getClass().getName());
        HttpClientHttpHeaderCredentials httpClientHttpHeaderCredentials = (HttpClientHttpHeaderCredentials) credentials;

            }

            String errorName;
            final Throwable cause = e.getCause();
            if (cause != null) {
                errorName = cause.getClass().getCanonicalName();
            } else {
                errorName = e.getClass().getCanonicalName();
            }
            storeFailureUrl(crawlerContext, urlQueue, errorName, e);
        } catch (final ContainerNotAvailableException e) {

    public ConsumerTargetTypeProvider() {
        configuredTargetTypes.put(IdeaSingleEntryLibraryDependency.class.getCanonicalName(), IdeaSingleEntryLibraryDependency.class);
        configuredTargetTypes.put(IdeaModuleDependency.class.getCanonicalName(), BackwardsCompatibleIdeaModuleDependency.class);
    }

    @Override

        if (!type.isInstance(remote)) {
            if (remote != null) {
                LOGGER.info("Replacing remote build cache type {} with {}", remote.getClass().getCanonicalName(), type.getCanonicalName());
            }
            remote = createRemoteCacheConfiguration(instantiator, type, registrations);
        }
        T configurationObject = Cast.uncheckedNonnullCast(remote);

    public static Slf4jConfiguration getConfiguration(ILoggerFactory loggerFactory) {
        String slf4jBinding = loggerFactory.getClass().getCanonicalName();

        try {
            Enumeration<URL> resources =
                    Slf4jConfigurationFactory.class.getClassLoader().getResources(RESOURCE);

            while (resources.hasMoreElements()) {

        return new InvalidUserDataException(String.format("The task '%s' (%s) is not a subclass of the given type (%s).", name, actual.getCanonicalName(), expected.getCanonicalName()));
    }

    @Override
    public TaskProvider<T> named(String name) throws UnknownTaskException {
        return (TaskProvider<T>) super.named(name);
    }

    @Override

        return outputStream -> {
            Properties properties = new Properties();
            properties.setProperty(BUILD_INVOCATION_ID_KEY, currentBuildInvocationId);
            properties.setProperty(TYPE_KEY, workType.getCanonicalName());
            properties.setProperty(IDENTITY_KEY, identity);
            properties.setProperty(CACHE_KEY, buildCacheKey.toString());