}

    @Override
    public String getVersion() {
        return "";
    }

    @Override
    public Nature getNature() {
        return artifact.isSnapshot() ? Nature.RELEASE_OR_SNAPSHOT : Nature.RELEASE;
    }

        return buffer.toString();
    }

    public int getNature() {
        return RELEASE;
    }

    public ArtifactRepositoryPolicy getPolicy(ArtifactRepository repository) {
        int nature = getNature();
        if ((nature & RepositoryMetadata.RELEASE_OR_SNAPSHOT) == RepositoryMetadata.RELEASE_OR_SNAPSHOT) {
            ArtifactRepositoryPolicy policy = new ArtifactRepositoryPolicy(repository.getReleases());

        return "";
    }

    @Override
    public String getVersion() {
        return "";
    }

    @Override
    public Nature getNature() {
        return Nature.RELEASE_OR_SNAPSHOT;
    }

        } finally {
            if (configurator != null) {
                try {
                    container.release(configurator);
                } catch (ComponentLifecycleException e) {
                    logger.debug("Failed to release mojo configurator - ignoring.");
                }
            }
        }
    }

    private void validateParameters(

        private static final List<String> QUALIFIERS =
                Arrays.asList("alpha", "beta", "milestone", "rc", "snapshot", "", "sp");
        private static final List<String> RELEASE_QUALIFIERS = Arrays.asList("ga", "final", "release");

        private static final Properties ALIASES = new Properties();

        static {
            ALIASES.put("cr", "rc");
        }

        /**

@Experimental
@Consumer
public interface VersionResolver extends Service {

    /**
     * Resolves an artifact's meta version (if any) to a concrete version. For example, resolves "1.0-SNAPSHOT"
     * to "1.0-20090208.132618-23" or "RELEASE"/"LATEST" to "2.0".
     *
     * @param session The repository session, must not be {@code null}.
     * @param artifactCoordinate The artifact coordinate for which the version needs to be resolved, must not be {@code null}

    }

    public boolean isSnapshot() {
        return artifact.isSnapshot();
    }

    public int getNature() {
        return isSnapshot() ? SNAPSHOT : RELEASE;
    }

    public ArtifactRepository getRepository() {
        return artifact.getRepository();
    }

    public void setRepository(ArtifactRepository remoteRepository) {

                acquiredAggregatorLock = null;
                acquiredProjectLock = null;
            }
        }

        @Override
        public void close() {
            // release the lock in the reverse order of the acquisition
            if (acquiredProjectLock != null) {
                acquiredProjectLock.unlock();
            }
            if (acquiredAggregatorLock != null) {

        injectPluginDeclarationFromProject(plugin, project);

        // If there is no version to be found then we need to look in the repository metadata for
        // this plugin and see what's specified as the latest release.
        //
        if (plugin.getVersion() == null) {
            resolvePluginVersion(plugin, session, project);
        }

        return pluginManager.getMojoDescriptor(

            ArtifactRepositoryPolicy snapshots = buildArtifactRepositoryPolicy(repo.getSnapshots());

            ArtifactRepositoryPolicy releases = buildArtifactRepositoryPolicy(repo.getReleases());

            return createArtifactRepository(id, url, getLayout(repo.getLayout()), snapshots, releases);
        } else {
            return null;
        }
    }

    private ArtifactRepository createRepository(