Java Code Examples for org.eclipse.core.variables.IStringVariableManager#performStringSubstitution()

private String[] getCommandResolved(IStringVariableManager variableManager) throws CoreException {
    String[] commandArray = null;
    switch(commandTokenizer) {
        case commandTokenizerSpaces:
            commandArray = Utils.splitSpaces(commandValue);
        break;
        case commandTokenizerSpacesAndQuotes:
            commandArray = Utils.splitSpacesAndQuotes(commandValue, false);
        break;
        case commandTokenizerSpacesAndQuotesSkip:
            commandArray = Utils.splitSpacesAndQuotes(commandValue, true);
        break;
        case commandTokenizerDisabled:
            commandArray = new String[1];
            commandArray[0] = commandValue;
        break;
        default:
            throw new IllegalArgumentException();
    }
    // resolve the variables
    for (int i=0;i<commandArray.length;i++) {
        commandArray[i] = variableManager.performStringSubstitution(commandArray[i], false);
        Activator.logDebug("exc" + i + ":>" + commandArray[i]+ "<");
    }
    return commandArray;
}
 

/**
 * @return the initial commands set in the preferences
 */
@Override
public String getInitialCommands() {
    String str = PydevDebugPlugin.getDefault().getPreferenceStore()
            .getString(PydevConsoleConstants.INITIAL_INTERPRETER_CMDS);
    try {
        // Expand any eclipse variables in the GUI
        IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
        str = manager.performStringSubstitution(str, false);
    } catch (CoreException e) {
        // Unreachable as false passed to reportUndefinedVariables above
        Log.log(e);
    }
    if (!str.endsWith("\n")) {
        str += "\n";
    }

    if (additionalInitialComands != null) {
        str += additionalInitialComands;
    }
    return str;
}
 

public static void fillMapWithEnv(String[] env, Map<String, String> hashMap,
        Set<String> keysThatShouldNotBeUpdated, IStringVariableManager manager) {
    if (env == null || env.length == 0) {
        // nothing to do
        return;
    }

    if (keysThatShouldNotBeUpdated == null) {
        keysThatShouldNotBeUpdated = Collections.emptySet();
    }

    for (String s : env) {
        Tuple<String, String> sp = StringUtils.splitOnFirst(s, '=');
        if (sp.o1.length() != 0 && sp.o2.length() != 0 && !keysThatShouldNotBeUpdated.contains(sp.o1)) {
            String value = sp.o2;
            if (manager != null) {
                try {
                    value = manager.performStringSubstitution(value, false);
                } catch (CoreException e) {
                    // Unreachable as false passed to reportUndefinedVariables above
                }
            }
            hashMap.put(sp.o1, value);
        }
    }
}
 

/**
 * Return default template preference
 * 
 * @return String The string of default template preference
 */
public String getTemplatePreference( )
{
	String temp = PreferenceFactory.getInstance( )
			.getPreferences( this, UIUtil.getCurrentProject( ) )
			.getString( TEMPLATE_PREFERENCE );
	String str = temp;
	try
	{
		IStringVariableManager mgr = VariablesPlugin.getDefault( )
				.getStringVariableManager( );
		str = mgr.performStringSubstitution( temp );
	}
	catch ( CoreException e )
	{
		str = temp;
	}

	return str;
}
 

private void setDefaultMessage( String odaDesignerID )
{
	String msgExpr = Messages.getMessage( "datasource.page.title" );
	// "Define ${odadesignerid.ds.displayname} Data Source";
	String dsMsgExpr = msgExpr.replace( "odadesignerid", odaDesignerID ); //$NON-NLS-1$

	IStringVariableManager varMgr = org.eclipse.core.variables.VariablesPlugin.getDefault( )
			.getStringVariableManager( );
	try
	{
		DEFAULT_MESSAGE = varMgr.performStringSubstitution( dsMsgExpr, false );
	}
	catch ( CoreException ex )
	{
		// TODO Auto-generated catch block
	}

}
 

/**
 * Validates that the file with the specified absolute path exists and can
 * be opened.
 *
 * @param path
 *                   The path of the file to validate
 * @return a status without error if the path is valid
 */
protected static IStatus validateAbsoluteFilePath(String path) {

	final StatusInfo status= new StatusInfo();
	IStringVariableManager variableManager= VariablesPlugin.getDefault().getStringVariableManager();
	try {
		path= variableManager.performStringSubstitution(path);
		if (path.length() > 0) {

			final File file= new File(path);
			if (!file.exists() && (!file.isAbsolute() || !file.getParentFile().canWrite()))
				status.setError(PreferencesMessages.SpellingPreferencePage_dictionary_error);
			else if (file.exists() && (!file.isFile() || !file.isAbsolute() || !file.canRead() || !file.canWrite()))
				status.setError(PreferencesMessages.SpellingPreferencePage_dictionary_error);
		}
	} catch (CoreException e) {
		status.setError(e.getLocalizedMessage());
	}
	return status;
}
 

private void validateAbsoluteFilePath() {
    MyStatus ms = new MyStatus(IStatus.OK, XdsEditorsPlugin.PLUGIN_ID, null);
    String path = fDictionaryPath == null ? "" : fDictionaryPath.getText().trim(); //$NON-NLS-1$
    if (!path.isEmpty()) {
   	    IStringVariableManager variableManager= VariablesPlugin.getDefault().getStringVariableManager();
   	    try {
   	        path= variableManager.performStringSubstitution(path);
   	        if (path.length() > 0) {
   	            final File file= new File(path);
   	            if (!file.exists() || !file.isFile() || !file.isAbsolute() || !file.canRead()) {
                       ms = new MyStatus(IStatus.ERROR, XdsEditorsPlugin.PLUGIN_ID, Messages.SpellingPreferenceBlock_BadDictFile);
   	            } else if (!file.getParentFile().canWrite() || !file.canWrite()) {
   	                ms = new MyStatus(IStatus.ERROR, XdsEditorsPlugin.PLUGIN_ID, Messages.SpellingPreferenceBlock_RWAccessRequired);
   	            }
   	        }
   	    } catch (CoreException e) {
   	        ms = new MyStatus(IStatus.ERROR, XdsEditorsPlugin.PLUGIN_ID, e.getLocalizedMessage());
   	    }
    }
    
    if (ms.matches(IStatus.ERROR) || fFileStatus.matches(IStatus.ERROR)) {
        fFileStatus = ms;
        updateStatus();
    }
}
 

public static String performStringSubstitution(Sdk context, String line, boolean isReportUndefinedVariables) throws CoreException {
     IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
     if (context != null) {
line = line.replaceAll(String.format(Pattern.quote("${%s}"),
		XDS_HOME_VAR), StringUtils.replaceChars(
		context.getSdkHomePath(), '\\', '/'));
     }
     line = manager.performStringSubstitution(line, isReportUndefinedVariables);
     return line;
 }
 

public static String performMacroSubstitution(String input) {
	String ret = input;
	
	IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
	try {
		ret = manager.performStringSubstitution(ret, false);
	} catch (CoreException e) {
		// in case of a issue, keep the path as it is and log error
		CppcheclipsePlugin.logError("Path macro subsitution failed", e); //$NON-NLS-1$
	}		
	
	return ret;
}
 

private File locationToFile(String location) {
	if (location.matches("^.*\\$\\{.*\\}.*$")) { //$NON-NLS-1$
		IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
		try {
			location = manager.performStringSubstitution(location, false);
		} catch (CoreException e) {
			return null;
		}
	}
	return new File(location);
}
 

private File getWorkingDirectoryResolved(IStringVariableManager variableManager) throws CoreException {
    // working directory
    if (commandWorkingDir != null && !commandWorkingDir.isEmpty()) {
        variableManager.validateStringVariables(commandWorkingDir);
        Activator.logDebug("cwd: >" + commandWorkingDir + "<");
        return new File(variableManager.performStringSubstitution(commandWorkingDir, false));
    }
    return null;
}
 

public String apply(String input) {
  try {
    IStringVariableManager stringManager =
        VariablesPlugin.getDefault().getStringVariableManager();
    return stringManager.performStringSubstitution(input);
  } catch (CoreException e) {
    return "";
  }
}
 

/**
 * @param text
 * @return
 * @throws CoreException
 */
public static String getSubstitutedString(String text) throws CoreException {
	if (text == null)
		return ""; //$NON-NLS-1$
	IStringVariableManager mgr = VariablesPlugin.getDefault().getStringVariableManager();
	return mgr.performStringSubstitution(text);
}
 

private static String varParse(String unparsedString) {
	IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
	try {
		return manager.performStringSubstitution(unparsedString);
	} catch (CoreException e) {
		return unparsedString;
	}
}
 

public static String performStringSubstitution(String line, boolean isReportUndefinedVariables) throws CoreException {
	IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
	return manager.performStringSubstitution(line, isReportUndefinedVariables);
}
 

/**
 * @param project
 * @param parentPath
 * @return
 */
public String getResourceFolder( IProject project, String parentPath )
{
	String resourceFolder = ReportPlugin.getDefault( )
			.getResourcePreference( project );

	if ( resourceFolder == null || resourceFolder.equals( "" ) ) //$NON-NLS-1$
	{
		resourceFolder = parentPath;
	}

	if ( resourceFolder == null )
	{
		resourceFolder = "";//$NON-NLS-1$
	}

	String str = resourceFolder;
	try
	{
		IStringVariableManager mgr = VariablesPlugin.getDefault( )
				.getStringVariableManager( );
		str = mgr.performStringSubstitution( resourceFolder );
	}
	catch ( CoreException e )
	{
		str = resourceFolder;
	}

	resourceFolder = str;
	File file = new File( resourceFolder );

	if ( !file.isAbsolute( ) )
	{
		if ( project != null && project.getLocation( ) != null )
		{
			resourceFolder = project.getLocation( )
					.append( resourceFolder )
					.toOSString( );
		}
		else
		{
			if ( resourceFolder != null
					&& !resourceFolder.startsWith( File.separator ) )
			{
				resourceFolder = File.separator + resourceFolder;
			}
			resourceFolder = parentPath + resourceFolder;
		}
	}
	return resourceFolder;
}
 

public static String performVariableSubstitution(String string) throws CoreException {
	IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
	return manager.performStringSubstitution(string);
}
 

/**
 * Validates the value of the given string to determine if any/all variables
 * are valid
 *
 * @param expression
 *            expression with variables
 * @return whether the expression contained any variable values
 * @exception CoreException
 *                if variable resolution fails
 */
private String getValue(String expression) throws CoreException {
	IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
	return manager.performStringSubstitution(expression);
}