Java ArtifactFilterException.getMessage方法代码示例

import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException; //导入方法依赖的package包/类
/**
 * Filter the marked dependencies
 * 
 * @param artifacts
 * @return
 * @throws MojoExecutionException
 */
protected DependencyStatusSets filterMarkedDependencies( Set artifacts )
    throws MojoExecutionException
{
    // remove files that have markers already
    FilterArtifacts filter = new FilterArtifacts();
    filter.clearFilters();
    filter.addFilter( getMarkedArtifactFilter() );

    Set unMarkedArtifacts;
    try
    {
        unMarkedArtifacts = filter.filter( artifacts );
    }
    catch ( ArtifactFilterException e )
    {
        throw new MojoExecutionException(e.getMessage(),e);
    }

    // calculate the skipped artifacts
    Set skippedArtifacts = new HashSet();
    skippedArtifacts.addAll( artifacts );
    skippedArtifacts.removeAll( unMarkedArtifacts );

    return new DependencyStatusSets( unMarkedArtifacts, null, skippedArtifacts );
}
 

import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException; //导入方法依赖的package包/类
@Override
protected Set<Artifact> filterDependencies(Set<Artifact> dependencies,
                                           FilterArtifacts filters) throws MojoExecutionException {
    try {
        Set<Artifact> filtered = new LinkedHashSet<Artifact>(dependencies);

        @SuppressWarnings("unchecked")
        Collection<ArtifactsFilter> filtersToUse = filters.getFilters();
        filtersToUse.addAll(getAdditionalFilters());

        filtered.retainAll(filters.filter(dependencies));
        return filtered;
    }
    catch (ArtifactFilterException ex) {
        throw new MojoExecutionException(ex.getMessage(), ex);
    }
}
 

import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException; //导入方法依赖的package包/类
protected DependencyStatusSets filterMarkedDependencies(Set artifacts) throws MojoExecutionException {
    // remove files that have markers already
    FilterArtifacts filter = new FilterArtifacts();
    filter.clearFilters();
    filter.addFilter(getMarkedArtifactFilter());

    Set unMarkedArtifacts;
    try {
        unMarkedArtifacts = filter.filter(artifacts);
    } catch (ArtifactFilterException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    }

    // calculate the skipped artifacts
    Set skippedArtifacts = new HashSet();
    skippedArtifacts.addAll(artifacts);
    skippedArtifacts.removeAll(unMarkedArtifacts);

    return new DependencyStatusSets(unMarkedArtifacts, null, skippedArtifacts);
}
 

import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException; //导入方法依赖的package包/类
/**
 * 
 * Method creates filters and filters the projects dependencies. This method
 * also transforms the dependencies if classifier is set. The dependencies
 * are filtered in least specific to most specific order
 * 
 * @param stopOnFailure
 * @return DependencyStatusSets - Bean of TreeSets that contains information
 *         on the projects dependencies
 * @throws MojoExecutionException 
 */
protected DependencyStatusSets getDependencySets( boolean stopOnFailure )
    throws MojoExecutionException
{
    // add filters in well known order, least specific to most specific
    FilterArtifacts filter = new FilterArtifacts();

    filter.addFilter( new TransitivityFilter( project.getDependencyArtifacts(), this.excludeTransitive ) );
    filter.addFilter( new ScopeFilter( this.includeScope, this.excludeScope ) );
    filter.addFilter( new TypeFilter( this.includeTypes, this.excludeTypes ) );
    filter.addFilter( new ClassifierFilter( this.includeClassifiers, this.excludeClassifiers ) );
    filter.addFilter( new GroupIdFilter( this.includeGroupIds, this.excludeGroupIds ) );
    filter.addFilter( new ArtifactIdFilter( this.includeArtifactIds, this.excludeArtifactIds ) );

    // start with all artifacts.
    Set artifacts = project.getArtifacts();

    // perform filtering
    try
    {
        artifacts = filter.filter( artifacts );
    }
    catch ( ArtifactFilterException e )
    {
        throw new MojoExecutionException(e.getMessage(),e);
    }

    // transform artifacts if classifier is set
    DependencyStatusSets status = null;
    if ( StringUtils.isNotEmpty( classifier ) )
    {
        status = getClassifierTranslatedDependencies( artifacts, stopOnFailure );
    }
    else
    {
        status = filterMarkedDependencies( artifacts );
    }

    return status;
}
 

import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
protected Set<Artifact> filterDependencies(Set<Artifact> dependencies,
		FilterArtifacts filters) throws MojoExecutionException {
	try {
		return filters.filter(dependencies);
	}
	catch (ArtifactFilterException e) {
		throw new MojoExecutionException(e.getMessage(), e);
	}
}
 

import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException; //导入方法依赖的package包/类
@Override
protected Set<Artifact> filterDependencies(Set<Artifact> dependencies,
                                           FilterArtifacts filters) throws MojoExecutionException {
    try {
        Set<Artifact> filtered = new LinkedHashSet<Artifact>(dependencies);

        filters.getFilters().addAll(getAdditionalFilters());

        filtered.retainAll(filters.filter(dependencies));
        return filtered;
    }
    catch (ArtifactFilterException ex) {
        throw new MojoExecutionException(ex.getMessage(), ex);
    }
}
 

import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException; //导入方法依赖的package包/类
protected DependencyStatusSets getDependencySets(boolean stopOnFailure) throws MojoExecutionException {
    // add filters in well known order, least specific to most specific
    FilterArtifacts filter = new FilterArtifacts();

    filter.addFilter(new ProjectTransitivityFilter(project.getDependencyArtifacts(), false));
    filter.addFilter(new ScopeFilter(this.includeScope, this.excludeScope));
    filter.addFilter(new TypeFilter(this.includeTypes, this.excludeTypes));
    filter.addFilter(new ClassifierFilter(this.includeClassifiers, this.excludeClassifiers));
    filter.addFilter(new GroupIdFilter(this.includeGroupIds, this.excludeGroupIds));
    filter.addFilter(new ArtifactIdFilter(this.includeArtifactIds, this.excludeArtifactIds));

    // explicitly filter our nar dependencies
    filter.addFilter(new TypeFilter("", "nar"));

    // start with all artifacts.
    Set artifacts = project.getArtifacts();

    // perform filtering
    try {
        artifacts = filter.filter(artifacts);
    } catch (ArtifactFilterException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    }

    // transform artifacts if classifier is set
    final DependencyStatusSets status;
    if (StringUtils.isNotEmpty(copyDepClassifier)) {
        status = getClassifierTranslatedDependencies(artifacts, stopOnFailure);
    } else {
        status = filterMarkedDependencies(artifacts);
    }

    return status;
}
 

import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException; //导入方法依赖的package包/类
private NarDependency getNarDependency() throws MojoExecutionException {
    NarDependency narDependency = null;

    // get nar dependencies
    FilterArtifacts filter = new FilterArtifacts();
    filter.addFilter(new TypeFilter("nar", ""));

    // start with all artifacts.
    Set artifacts = project.getArtifacts();

    // perform filtering
    try {
        artifacts = filter.filter(artifacts);
    } catch (ArtifactFilterException e) {
        throw new MojoExecutionException(e.getMessage(), e);
    }

    // ensure there is a single nar dependency
    if (artifacts.size() > 1) {
        throw new MojoExecutionException("Each NAR represents a ClassLoader. A NAR dependency allows that NAR's ClassLoader to be "
                + "used as the parent of this NAR's ClassLoader. As a result, only a single NAR dependency is allowed.");
    } else if (artifacts.size() == 1) {
        final Artifact artifact = (Artifact) artifacts.iterator().next();

        narDependency = new NarDependency(artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion());
    }

    return narDependency;
}
 

import org.apache.maven.shared.artifact.filter.collection.ArtifactFilterException; //导入方法依赖的package包/类
/**
 * Preprocesses the list of ArtifactItems. This method defaults the
 * outputDirectory if not set and creates the output Directory if it doesn't
 * exist.
 * 
 * @param removeVersion
 *            remove the version from the filename.
 * @return An ArrayList of preprocessed ArtifactItems
 * 
 * @throws MojoExecutionException
 *             with a message if an error occurs.
 * 
 * @see ArtifactItem
 */
protected ArrayList getProcessedArtifactItems( boolean removeVersion )
    throws MojoExecutionException
{
    if ( artifactItems == null || artifactItems.size() < 1 )
    {
        throw new MojoExecutionException( "There are no artifactItems configured." );
    }

    Iterator iter = artifactItems.iterator();
    while ( iter.hasNext() )
    {
        ArtifactItem artifactItem = (ArtifactItem) iter.next();
        this.getLog().info( "Configured Artifact: " + artifactItem.toString() );

        if ( artifactItem.getOutputDirectory() == null )
        {
            artifactItem.setOutputDirectory( this.outputDirectory );
        }
        artifactItem.getOutputDirectory().mkdirs();

        // make sure we have a version.
        if ( StringUtils.isEmpty( artifactItem.getVersion() ) )
        {
            fillMissingArtifactVersion( artifactItem );
        }

        artifactItem.setArtifact( this.getArtifact( artifactItem ) );

        if ( StringUtils.isEmpty( artifactItem.getDestFileName() ) )
        {
            artifactItem.setDestFileName( DependencyUtil.getFormattedFileName( artifactItem.getArtifact(),
                                                                               removeVersion ) );
        }

        try
        {
            artifactItem.setNeedsProcessing( checkIfProcessingNeeded( artifactItem ) );
        }
        catch ( ArtifactFilterException e )
        {
            throw new MojoExecutionException (e.getMessage(),e);
        }
    }
    return artifactItems;
}