this.fileSuffix = fileSuffix;

        initializeCleanupMonitoring();
    }

    private void initializeCleanupMonitoring() {
        callerInfo = new NullPointerException().getStackTrace()[2];

        Runnable warning = this::maybeWarnAboutCleanUp;

        cleanupWarning = new Thread(warning);

        Runtime.getRuntime().addShutdownHook(cleanupWarning);
    }

    private void maybeWarnAboutCleanUp() {

        public Thread newThread(Runnable r) {
            Thread newThread = new Thread(GROUP, r, "resolver-" + THREAD_NUMBER.getAndIncrement());
            newThread.setDaemon(true);
            newThread.setContextClassLoader(null);
            return newThread;
        }
    }

    private class ResolveTask implements Runnable {

        private final ClassLoader classLoader;

capitalizeFirstLette(String); public static String lowercaseFirstLetter(String); public static String addAndDeHump(String); } org/codehaus/plexus/util/SweeperPool$Sweeper.class package org.codehaus.plexus.util; synchronized class SweeperPool$Sweeper implements Runnable { private final transient SweeperPool pool; private transient boolean service; private final transient int sweepInterval; public void SweeperPool$Sweeper(SweeperPool, int); public void run(); public synchronized void start(); public synchronized...

            try {
                this.delegate = versionScheme.parseVersion(delegateValue);
            } catch (InvalidVersionSpecificationException e) {
                throw new VersionParserException("Unable to parse version: " + delegateValue, e);
            }
        }

        @Override
        public int compareTo(Version o) {
            if (o instanceof DefaultVersion) {

            } else {
                return xml.read(inputStream, request.isStrict());
            }
        } catch (Exception e) {
            throw new XmlReaderException("Unable to read toolchains: " + getMessage(e), getLocation(e), e);
        }
    }

    @Override
    public void write(XmlWriterRequest<PersistedToolchains> request) throws XmlWriterException {

                    return xml.read(is, request.isStrict(), source);
                }
            }
        } catch (Exception e) {
            throw new XmlReaderException("Unable to read model: " + getMessage(e), getLocation(e), e);
        }
    }

    @Override
    public void write(XmlWriterRequest<Model> request) throws XmlWriterException {
        nonNull(request, "request");

                    Key.of(mojoDescriptor.getImplementationClass(), mojoDescriptor.getRoleHint())));

        } catch (Exception e) {
            throw new PluginContainerException(mojoDescriptor, pluginRealm, "Unable to lookup Mojo", e);
        }

        XmlNode dom = mojoExecution.getConfiguration() != null
                ? mojoExecution.getConfiguration().getDom()
                : null;

                    paths.put(artifact, path);
                }
            }
            return () -> paths;
        } catch (ArtifactResolutionException e) {
            throw new ArtifactResolverException("Unable to resolve artifact: " + e.getMessage(), e);
        }
    }

                    return session.getNode(result.getRoot(), request.getVerbose());
                }
            };
        } catch (DependencyCollectionException e) {
            throw new DependencyCollectorException("Unable to collect dependencies", e);
        }
    }

                            .getLifecycleMappings()
                            .values()));
                } catch (Exception e) {
                    throw new RuntimeException("Unable to load plugin lifecycles", e);
                }
            }

            @Override
            public ClassLoader getClassLoader() {
                return delegate.getMojoDescriptor().getRealm();
            }