Java StringUtils.isNotEmpty方法代码示例

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
public boolean canTransformResource( String r )
{
    if ( StringUtils.isNotEmpty( resource ) && r.endsWith( resource ) )
    {
        return true;
    }
    
    if ( resources != null )
    {
        for ( String resourceEnd : resources )
        {
            if ( r.endsWith( resourceEnd ) )
            {
                return true;
            }
        }
    }

    return false;
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
private static void addBounds( PropertyVersionsBuilder builder, String rawVersionRange, String propertyRef,
                               String evaluatedVersionRange )
{
    Pattern lowerBound = Pattern.compile( "([(\\[])([^,]*)," + RegexUtils.quote( propertyRef ) + "([)\\]])" );
    Pattern upperBound = Pattern.compile( "([(\\[])" + RegexUtils.quote( propertyRef ) + ",([^,]*)([)\\]])" );
    Matcher m = lowerBound.matcher( rawVersionRange );
    if ( m.find() )
    {
        boolean includeLower = "[".equals( m.group( 1 ) );
        String lowerLimit = m.group( 2 );
        if ( StringUtils.isNotEmpty( lowerLimit ) )
        {
            builder.addLowerBound( lowerLimit, includeLower );
        }
    }
    m = upperBound.matcher( rawVersionRange );
    if ( m.find() )
    {
        boolean includeUpper = "[".equals( m.group( 3 ) );
        String upperLimit = m.group( 2 );
        if ( StringUtils.isNotEmpty( upperLimit ) )
        {
            builder.addUpperBound( upperLimit, includeUpper );
        }
    }
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的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.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
/**
 * 
 * Transform artifacts
 * 
 * @param artifacts
 * @param stopOnFailure
 * @return DependencyStatusSets - Bean of TreeSets that contains information
 *         on the projects dependencies
 * @throws MojoExecutionException
 */
protected DependencyStatusSets getClassifierTranslatedDependencies( Set artifacts, boolean stopOnFailure )
    throws MojoExecutionException
{
    Set unResolvedArtifacts = new HashSet();
    Set resolvedArtifacts = artifacts;
    DependencyStatusSets status = new DependencyStatusSets();

    // possibly translate artifacts into a new set of artifacts based on the
    // classifier and type
    // if this did something, we need to resolve the new artifacts
    if ( StringUtils.isNotEmpty( classifier ) )
    {
        ArtifactTranslator translator = new ClassifierTypeTranslator( this.classifier, this.type, this.factory );
        artifacts = translator.translate( artifacts, getLog() );

        status = filterMarkedDependencies( artifacts );

        // the unskipped artifacts are in the resolved set.
        artifacts = status.getResolvedDependencies();

        // resolve the rest of the artifacts
        ArtifactsResolver artifactsResolver = new DefaultArtifactsResolver( this.resolver, this.local,
                                                                            this.remoteRepos, stopOnFailure );
        resolvedArtifacts = artifactsResolver.resolve( artifacts, getLog() );

        // calculate the artifacts not resolved.
        unResolvedArtifacts.addAll( artifacts );
        unResolvedArtifacts.removeAll( resolvedArtifacts );
    }

    // return a bean of all 3 sets.
    status.setResolvedDependencies( resolvedArtifacts );
    status.setUnResolvedDependencies( unResolvedArtifacts );

    return status;
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
/**
 * Builds the file name. If removeVersion is set, then the file name must be
 * reconstructed from the artifactId, Classifier (if used) and Type.
 * Otherwise, this method returns the artifact file name.
 * 
 * @param artifact
 *            File to be formatted.
 * @param removeVersion
 *            Specifies if the version should be removed from the file name.
 * @return Formatted file name in the format
 *         artifactId-[version]-[classifier].[type]
 */
public static String getFormattedFileName( Artifact artifact, boolean removeVersion )
{
    String destFileName = null;

    // if there is a file and we aren't stripping the version, just get the
    // name directly
    if ( artifact.getFile() != null && !removeVersion )
    {
        destFileName = artifact.getFile().getName();
    }
    else
    // if offline
    {
        String versionString = null;
        if ( !removeVersion )
        {
            versionString = "-" + artifact.getVersion();
        }
        else
        {
            versionString = "";
        }

        String classifierString = "";

        if ( StringUtils.isNotEmpty( artifact.getClassifier() ) )
        {
            classifierString = "-" + artifact.getClassifier();
        }

        destFileName = artifact.getArtifactId() + versionString + classifierString + "."
            + artifact.getArtifactHandler().getExtension();
    }
    return destFileName;
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
private static String getDependencyId( Artifact artifact, boolean removeVersion )
{
    StringBuffer sb = new StringBuffer();

    sb.append( artifact.getArtifactId() );

    if ( StringUtils.isNotEmpty( artifact.getClassifier() ) )
    {
        sb.append( "-" );
        sb.append( artifact.getClassifier() );
    }

    if ( !removeVersion )
    {
        sb.append( "-" );
        sb.append( artifact.getVersion() );
        sb.append( "-" );
        sb.append( artifact.getType() );
    }
    else
    {
        // if the classifier and type are the same (sources), then don't
        // repeat.
        // avoids names like foo-sources-sources
        if ( !StringUtils.equals( artifact.getClassifier(), artifact.getType() ) )
        {
            sb.append( "-" );
            sb.append( artifact.getType() );
        }
    }
    return sb.toString();
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
protected File getMarkerFile()
  {
File markerFile = null;
if ( this.artifactItem == null 
	|| ( StringUtils.isEmpty( this.artifactItem.getIncludes() )
	&&	StringUtils.isEmpty( this.artifactItem.getExcludes() ) ) )
{
	markerFile = new StubMarkerFile( this.markerFilesDirectory, this.artifact.getId().replace( ':', '-' ) + ".marker" );
}
else
{
	int includeExcludeHash = 0;
	
	if ( StringUtils.isNotEmpty( this.artifactItem.getIncludes() ) )
	{
		includeExcludeHash += this.artifactItem.getIncludes().hashCode();
	}
	
	if ( StringUtils.isNotEmpty( this.artifactItem.getExcludes() ) )
	{
		includeExcludeHash += this.artifactItem.getExcludes().hashCode();
	}
	
	markerFile = new StubMarkerFile( this.markerFilesDirectory, this.artifact.getId().replace( ':', '-' ) + includeExcludeHash );
}

return markerFile;
  }
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
public static DockerImageType getDockerImageType(final ContainerSetting containerSetting) {
    if (containerSetting == null || StringUtils.isEmpty(containerSetting.getImageName())) {
        return DockerImageType.NONE;
    }

    final boolean isCustomRegistry = StringUtils.isNotEmpty(containerSetting.getRegistryUrl());
    final boolean isPrivate = StringUtils.isNotEmpty(containerSetting.getServerId());

    if (isCustomRegistry) {
        return isPrivate ? DockerImageType.PRIVATE_REGISTRY : DockerImageType.UNKNOWN;
    } else {
        return isPrivate ? DockerImageType.PRIVATE_DOCKER_HUB : DockerImageType.PUBLIC_DOCKER_HUB;
    }
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
public String getAuthType() {
    final AuthenticationSetting authSetting = getAuthenticationSetting();
    if (authSetting == null) {
        return "AzureCLI";
    }
    if (StringUtils.isNotEmpty(authSetting.getServerId())) {
        return "ServerId";
    }
    if (authSetting.getFile() != null) {
        return "AuthFile";
    }
    return "Unknown";
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
protected String[] getRunSingleFunctionCommand() {
    String command = format(getRunFunctionTemplate(), getDeploymentStageDirectory(), getTargetFunction());
    if (StringUtils.isNotEmpty(getInputString())) {
        command = command.concat(" -c ").concat(getInputString());
    } else if (getInputFile() != null) {
        command = command.concat(" -f ").concat(getInputFile().getAbsolutePath());
    }
    return buildCommand(command);
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
private String select( String dominant, String recessive )
{
    if ( StringUtils.isNotEmpty( dominant ) )
    {
        return dominant;
    }
    else
    {
        return recessive;
    }
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
private static File stringToFile( String string )
{
    if ( StringUtils.isNotEmpty( string ) )
    {
        return new File( string );
    }

    return null;
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
/**
 * Either return the submitted errorMessage or replace it with the custom message set in the rule extended
 * by the property name.
 *
 * @param errorMessage
 * @return
 */
String createResultingErrorMessage( String errorMessage )
{
    if ( StringUtils.isNotEmpty( message ) )
    {
        return "Property '" + property + "' must be overridden:\n" + message;
    }
    else
    {
        return errorMessage;
    }
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
private List<String> getSplittedProperties( String commaSeparatedProperties )
{
    List<String> propertiesList = Collections.emptyList();
    if ( StringUtils.isNotEmpty( commaSeparatedProperties ) )
    {
        String[] splittedProps = StringUtils.split( commaSeparatedProperties, "," );
        propertiesList = Arrays.asList( StringUtils.stripAll( splittedProps ) );
    }
    return propertiesList;
}
 

import org.codehaus.plexus.util.StringUtils; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected R createKeytoolRequest()
{
    R request = super.createKeytoolRequest();

    if ( StringUtils.isNotEmpty( keystore ) )
    {

        File file = getFile( keystore );

        // make sure the parent directory of the keystore exists

        boolean mkdirs = file.getParentFile().mkdirs();
        getLog().debug( "mdkirs: " + mkdirs + " " + file.getParentFile() );

        // force to not use this parameter
        request.setKeystore( file.getAbsolutePath() );
    }

    request.setProviderarg( providerarg );
    request.setProviderclass( providerclass );
    request.setProvidername( providername );
    request.setProviderpath( providerpath );
    request.setStorepass( storepass );
    request.setStoretype( storetype );
    return request;
}