Case Study: adding data and statistics

[ifi-stolz-refaktor.git] / case-study / jdt-after / ui / org / eclipse / jdt / internal / ui / dialogs / StatusInfo.java

/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.ui.dialogs;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.xml.sax.SAXException;

import org.w3c.dom.Element;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.jface.dialogs.IDialogSettings;

import org.eclipse.jface.text.templates.TemplateContextType;
import org.eclipse.jface.text.templates.TemplateException;

import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaModelStatus;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;

import org.eclipse.jdt.internal.corext.fix.ConvertIterableLoopOperation;
import org.eclipse.jdt.internal.corext.fix.ConvertLoopOperation;
import org.eclipse.jdt.internal.corext.refactoring.TypeContextChecker;
import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
import org.eclipse.jdt.internal.corext.util.Messages;

import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.ui.PreferenceConstants;
import org.eclipse.jdt.ui.wizards.NewContainerWizardPage;
import org.eclipse.jdt.ui.wizards.NewElementWizardPage;
import org.eclipse.jdt.ui.wizards.NewTypeWizardPage;
import org.eclipse.jdt.ui.wizards.NewTypeWizardPage.InterfaceWrapper;

import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaUIMessages;
import org.eclipse.jdt.internal.ui.callhierarchy.CallHierarchyMessages;
import org.eclipse.jdt.internal.ui.callhierarchy.ExpandWithConstructorsConfigurationBlock.CallHierarchyTypesOrMembersDialog;
import org.eclipse.jdt.internal.ui.dialogs.GenerateToStringDialog.ToStringTemplatesDialog;
import org.eclipse.jdt.internal.ui.javadocexport.JavadocExportMessages;
import org.eclipse.jdt.internal.ui.javadocexport.JavadocOptionsManager;
import org.eclipse.jdt.internal.ui.javadocexport.JavadocReader;
import org.eclipse.jdt.internal.ui.javadocexport.RecentSettingsStore;
import org.eclipse.jdt.internal.ui.javaeditor.ASTProvider;
import org.eclipse.jdt.internal.ui.preferences.CodeAssistAdvancedConfigurationBlock;
import org.eclipse.jdt.internal.ui.preferences.CodeAssistFavoritesConfigurationBlock.FavoriteStaticMemberInputDialog;
import org.eclipse.jdt.internal.ui.preferences.ComplianceConfigurationBlock;
import org.eclipse.jdt.internal.ui.preferences.EditTemplateDialog;
import org.eclipse.jdt.internal.ui.preferences.ImportOrganizeConfigurationBlock;
import org.eclipse.jdt.internal.ui.preferences.ImportOrganizeInputDialog;
import org.eclipse.jdt.internal.ui.preferences.JavaEditorHoverConfigurationBlock;
import org.eclipse.jdt.internal.ui.preferences.JavadocConfigurationBlock;
import org.eclipse.jdt.internal.ui.preferences.PreferencesMessages;
import org.eclipse.jdt.internal.ui.preferences.TodoTaskInputDialog;
import org.eclipse.jdt.internal.ui.preferences.TypeFilterInputDialog;
import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels;
import org.eclipse.jdt.internal.ui.wizards.NewSourceFolderWizardPage;
import org.eclipse.jdt.internal.ui.wizards.NewWizardMessages;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.AccessRuleEntryDialog;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.AddSourceFolderWizardPage;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.BuildPathSupport;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.BuildPathsBlock;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.CPListElement;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.CPVariableElement;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.ClasspathContainerDefaultPage;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.EditVariableEntryDialog;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.ExclusionInclusionEntryDialog;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.NewContainerDialog;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.NewSourceFolderDialog;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.NewVariableEntryDialog;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.SourceAttachmentBlock;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.VariableCreationDialog;

/**
 * A settable IStatus.
 * Can be an error, warning, info or ok. For error, info and warning states,
 * a message describes the problem.
 */
public class StatusInfo implements IStatus {

	public static final IStatus OK_STATUS= new StatusInfo();

	private String fStatusMessage;
	private int fSeverity;

	/**
	 * Creates a status set to OK (no message)
	 */
	public StatusInfo() {
		this(OK, null);
	}

	/**
	 * Creates a status .
	 * @param severity The status severity: ERROR, WARNING, INFO and OK.
	 * @param message The message of the status. Applies only for ERROR,
	 * WARNING and INFO.
	 */
	public StatusInfo(int severity, String message) {
		fStatusMessage= message;
		fSeverity= severity;
	}

	/**
	 *  Returns if the status' severity is OK.
	 */
	public boolean isOK() {
		return fSeverity == IStatus.OK;
	}

	/**
	 *  Returns if the status' severity is WARNING.
	 */
	public boolean isWarning() {
		return fSeverity == IStatus.WARNING;
	}

	/**
	 *  Returns if the status' severity is INFO.
	 */
	public boolean isInfo() {
		return fSeverity == IStatus.INFO;
	}

	/**
	 *  Returns if the status' severity is ERROR.
	 */
	public boolean isError() {
		return fSeverity == IStatus.ERROR;
	}

	/**
	 * @see IStatus#getMessage
	 */
	public String getMessage() {
		return fStatusMessage;
	}

	/**
	 * Sets the status to ERROR.
	 * @param errorMessage The error message (can be empty, but not null)
	 */
	public void setError(String errorMessage) {
		Assert.isNotNull(errorMessage);
		fStatusMessage= errorMessage;
		fSeverity= IStatus.ERROR;
	}

	/**
	 * Sets the status to WARNING.
	 * @param warningMessage The warning message (can be empty, but not null)
	 */
	public void setWarning(String warningMessage) {
		Assert.isNotNull(warningMessage);
		fStatusMessage= warningMessage;
		fSeverity= IStatus.WARNING;
	}

	/**
	 * Sets the status to INFO.
	 * @param infoMessage The info message (can be empty, but not null)
	 */
	public void setInfo(String infoMessage) {
		Assert.isNotNull(infoMessage);
		fStatusMessage= infoMessage;
		fSeverity= IStatus.INFO;
	}

	/**
	 * Sets the status to OK.
	 */
	public void setOK() {
		fStatusMessage= null;
		fSeverity= IStatus.OK;
	}

	/*
	 * @see IStatus#matches(int)
	 */
	public boolean matches(int severityMask) {
		return (fSeverity & severityMask) != 0;
	}

	/**
	 * Returns always <code>false</code>.
	 * @see IStatus#isMultiStatus()
	 */
	public boolean isMultiStatus() {
		return false;
	}

	/*
	 * @see IStatus#getSeverity()
	 */
	public int getSeverity() {
		return fSeverity;
	}

	/*
	 * @see IStatus#getPlugin()
	 */
	public String getPlugin() {
		return JavaUI.ID_PLUGIN;
	}

	/**
	 * Returns always <code>null</code>.
	 * @see IStatus#getException()
	 */
	public Throwable getException() {
		return null;
	}

	/**
	 * Returns always the error severity.
	 * @see IStatus#getCode()
	 */
	public int getCode() {
		return fSeverity;
	}

	/**
	 * Returns always an empty array.
	 * @see IStatus#getChildren()
	 */
	public IStatus[] getChildren() {
		return new IStatus[0];
	}

	/**
	 * Returns a string representation of the status, suitable
	 * for debugging purposes only.
	 */
	@Override
	public String toString() {
		StringBuffer buf = new StringBuffer();
		buf.append("StatusInfo "); //$NON-NLS-1$
		if (fSeverity == OK) {
			buf.append("OK"); //$NON-NLS-1$
		} else if (fSeverity == ERROR) {
			buf.append("ERROR"); //$NON-NLS-1$
		} else if (fSeverity == WARNING) {
			buf.append("WARNING"); //$NON-NLS-1$
		} else if (fSeverity == INFO) {
			buf.append("INFO"); //$NON-NLS-1$
		} else {
			buf.append("severity="); //$NON-NLS-1$
			buf.append(fSeverity);
		}
		buf.append(": "); //$NON-NLS-1$
		buf.append(fStatusMessage);
		return buf.toString();
	}

	public void generated_3764810824622344715(CallHierarchyTypesOrMembersDialog callhierarchytypesormembersdialog, String newText) {
		if (newText.length() == 0) {
			setError(""); //$NON-NLS-1$
		} else {
			IStatus val= JavaConventions.validateJavaTypeName(newText, JavaCore.VERSION_1_3, JavaCore.VERSION_1_3);
			if (val.matches(IStatus.ERROR)) {
				if (callhierarchytypesormembersdialog.fIsEditingMember)
					setError(CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_error_invalidMemberName);
				else
					setError(CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_error_invalidTypeName);
			} else {
				if (callhierarchytypesormembersdialog.doesExist(newText)) {
					setError(CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_error_entryExists);
				}
			}
		}
	}

	public void generated_5489507237624631287(ToStringTemplatesDialog tostringtemplatesdialog) {
		if (tostringtemplatesdialog.templateNames.size() > 0)
			setOK();
		else
			setError(JavaUIMessages.GenerateToStringDialog_templateManagerNoTemplateErrorMessage);
	}

	public IStatus generated_2255846643577716416() {
		setOK();
		return this;
	}

	public IStatus generated_7935792217506682991(Object[] selection) {
		if (selection.length == 1 && (selection[0] instanceof IFile))
			setOK();
		else
			setError(""); //$NON-NLS-1$
		return this;
	}

	public void generated_4279979400183450065(String filename) {
		if (filename.length() == 0) {
			setError(JavadocExportMessages.JavadocSpecificsWizardPage_overviewnotfound_error);
		} else {
			File file= new File(filename);
			String ext= filename.substring(filename.lastIndexOf('.') + 1);
			if (!file.isFile()) {
				setError(JavadocExportMessages.JavadocSpecificsWizardPage_overviewnotfound_error);
			} else if (!ext.equalsIgnoreCase("html")) { //$NON-NLS-1$
				setError(JavadocExportMessages.JavadocSpecificsWizardPage_overviewincorrect_error);
			}
		}
	}

	public void generated_4744902361355361343(String filename) {
		if (filename.length() == 0) {
			setError(JavadocExportMessages.JavadocSpecificsWizardPage_overviewnotfound_error);
		} else {
			File file= new File(filename);
			String ext= filename.substring(filename.lastIndexOf('.') + 1);
			if (!file.isFile()) {
				setError(JavadocExportMessages.JavadocStandardWizardPage_stylesheetnopath_error);
			} else if (!ext.equalsIgnoreCase("css")) { //$NON-NLS-1$
				setError(JavadocExportMessages.JavadocStandardWizardPage_stylesheetnotcss_error);
			}
		}
	}

	public void generated_7330943458652497803(String dest) {
		if (dest.length() == 0) {
			setError(JavadocExportMessages.JavadocTreeWizardPage_nodestination_error);
		}
		File file= new File(dest);
		if (!Path.ROOT.isValidPath(dest) || file.isFile()) {
			setError(JavadocExportMessages.JavadocTreeWizardPage_invaliddestination_error);
		}
		if (new File(dest, "package-list").exists() || new File(dest, "index.html").exists()) //$NON-NLS-1$//$NON-NLS-2$
			setWarning(JavadocExportMessages.JavadocTreeWizardPage_warning_mayoverwritefiles);
	}

	public void generated_7526970014727274382(JavadocOptionsManager javadocoptionsmanager, IFile xmlJavadocFile, List<?> currSelection, IDialogSettings javadocSection, String commandHistory) {
		if (commandHistory == null || commandHistory.length() == 0) {
			commandHistory= JavadocOptionsManager.initJavadocCommandDefault();
		}
		javadocoptionsmanager.fJavadocCommandHistory= javadocoptionsmanager.arrayFromFlatString(commandHistory);
	
		javadocoptionsmanager.fRecentSettings= new RecentSettingsStore(javadocSection);
	
		if (xmlJavadocFile != null) {
			try {
				JavadocReader reader= new JavadocReader(xmlJavadocFile.getContents());
				Element element= reader.readXML();
				if (element != null) {
					javadocoptionsmanager.loadFromXML(element);
					return;
				}
				setWarning(JavadocExportMessages.JavadocOptionsManager_antfileincorrectCE_warning);
			} catch (CoreException e) {
				JavaPlugin.log(e);
				setWarning(JavadocExportMessages.JavadocOptionsManager_antfileincorrectCE_warning);
			} catch (IOException e) {
				JavaPlugin.log(e);
				setWarning(JavadocExportMessages.JavadocOptionsManager_antfileincorrectIOE_warning);
			} catch (SAXException e) {
				setWarning(JavadocExportMessages.JavadocOptionsManager_antfileincorrectSAXE_warning);
			}
		}
		if (javadocSection != null) {
			javadocoptionsmanager.loadFromDialogStore(javadocSection, currSelection);
		} else {
			javadocoptionsmanager.loadDefaults(currSelection);
		}
	}

	public void generated_350887177935622380(TodoTaskInputDialog todotaskinputdialog) {
		String newText= todotaskinputdialog.fNameDialogField.getText();
		if (newText.length() == 0) {
			setError(PreferencesMessages.TodoTaskInputDialog_error_enterName);
		} else {
			if (newText.indexOf(',') != -1) {
				setError(PreferencesMessages.TodoTaskInputDialog_error_comma);
			} else if (todotaskinputdialog.fExistingNames.contains(newText)) {
				setError(PreferencesMessages.TodoTaskInputDialog_error_entryExists);
			} else if (Character.isWhitespace(newText.charAt(0)) ||  Character.isWhitespace(newText.charAt(newText.length() - 1))) {
				setError(PreferencesMessages.TodoTaskInputDialog_error_noSpace);
			}
		}
	}

	public void generated_7791403050701141905(JavaEditorHoverConfigurationBlock javaeditorhoverconfigurationblock) {
		javaeditorhoverconfigurationblock.fMainPreferencePage.setValid(isOK());
		StatusUtil.applyToStatusLine(javaeditorhoverconfigurationblock.fMainPreferencePage, this);
	}

	public void generated_5958990709099104451(EditTemplateDialog edittemplatedialog, String text) {
		setOK();
		TemplateContextType contextType= edittemplatedialog.fContextTypeRegistry.getContextType(edittemplatedialog.getContextId());
		if (contextType != null) {
			try {
				contextType.validate(text);
			} catch (TemplateException e) {
				setError(e.getLocalizedMessage());
			}
		}
	}

	public IStatus generated_8407535136467552723(String number) {
		if (number.length() == 0) {
			setError(PreferencesMessages.JavaEditorPreferencePage_empty_input);
		} else {
			try {
				int value= Integer.parseInt(number);
				if (value < 0)
					setError(Messages.format(PreferencesMessages.JavaEditorPreferencePage_invalid_input, number));
			} catch (NumberFormatException e) {
				setError(Messages.format(PreferencesMessages.JavaEditorPreferencePage_invalid_input, number));
			}
		}
		return this;
	}

	public void generated_1784172337949317156(ImportOrganizeInputDialog importorganizeinputdialog) {
		String newText= importorganizeinputdialog.fNameDialogField.getText();
		if (newText.length() == 0) {
			setError(""); //$NON-NLS-1$
		} else {
			if (newText.equals("*")) { //$NON-NLS-1$
				if (importorganizeinputdialog.doesExist("", importorganizeinputdialog.fIsStatic)) { //$NON-NLS-1$
					setError(PreferencesMessages.ImportOrganizeInputDialog_error_entryExists);
				}
			} else {
				IStatus val= JavaConventions.validateJavaTypeName(newText, JavaCore.VERSION_1_3, JavaCore.VERSION_1_3);
				if (val.matches(IStatus.ERROR)) {
					setError(PreferencesMessages.ImportOrganizeInputDialog_error_invalidName);
				} else {
					if (importorganizeinputdialog.doesExist(newText, importorganizeinputdialog.fIsStatic)) {
						setError(PreferencesMessages.ImportOrganizeInputDialog_error_entryExists);
					}
				}
			}
		}
	}

	public IStatus generated_4175166827632687071(String compliance, String source, String target) {
		if (JavaModelUtil.isVersionLessThan(compliance, source)) {
			setError(PreferencesMessages.ComplianceConfigurationBlock_src_greater_compliance);
			return this;
		}
	
		if (JavaModelUtil.isVersionLessThan(compliance, target)) {
			setError(PreferencesMessages.ComplianceConfigurationBlock_classfile_greater_compliance);
			return this;
		}
	
		if (ComplianceConfigurationBlock.VERSION_CLDC_1_1.equals(target)) {
			if (!ComplianceConfigurationBlock.VERSION_1_3.equals(source) || !JavaModelUtil.isVersionLessThan(compliance, ComplianceConfigurationBlock.VERSION_1_5)) {
				setError(PreferencesMessages.ComplianceConfigurationBlock_cldc11_requires_source13_compliance_se14);
				return this;
			}
		}
	
		// target must not be smaller than source
		if (!ComplianceConfigurationBlock.VERSION_1_3.equals(source) && JavaModelUtil.isVersionLessThan(target, source)) {
			setError(PreferencesMessages.ComplianceConfigurationBlock_classfile_greater_source);
			return this;
		}
	
		return this;
	}

	public IStatus generated_4057359700242502578(String value, String errorMessage) {
		if (JavaConventions.validateJavaTypeName(value, JavaCore.VERSION_1_5, JavaCore.VERSION_1_5).matches(IStatus.ERROR)
				|| value.indexOf('.') == -1)
			setError(errorMessage);
		return this;
	}

	public void generated_9109049189476184915(String newValue, CodeAssistAdvancedConfigurationBlock codeassistadvancedconfigurationblock) {
		if (newValue.length() == 0)
			setError(PreferencesMessages.CodeAssistAdvancedConfigurationBlock_parameterNameFromAttachedJavadoc_timeout_emptyInput);
		else {
			try {
				int number= Integer.parseInt(newValue);
				int min= 0;
				int max= 5000;
				if (number < min || number > max) {
					String msgFormat= PreferencesMessages.CodeAssistAdvancedConfigurationBlock_parameterNameFromAttachedJavadoc_timeout_invalidRange;
					String msg= Messages.format(msgFormat, new Object[] {new Integer(min), new Integer(max)});
					setError(msg);
				}
			} catch (NumberFormatException ex) {
				String msgFormat= PreferencesMessages.CodeAssistAdvancedConfigurationBlock_parameterNameFromAttachedJavadoc_timeout_invalidInput;
				String msg= Messages.format(msgFormat, newValue);
				setError(msg);
			}
		}
		codeassistadvancedconfigurationblock.fContext.statusChanged(this);
	}

	public IStatus generated_30797182611047098(String number) {
		if (number.length() == 0) {
			setError(PreferencesMessages.JavaBuildConfigurationBlock_empty_input);
		} else {
			try {
				int value= Integer.parseInt(number);
				if (value <= 0) {
					setError(Messages.format(PreferencesMessages.JavaBuildConfigurationBlock_invalid_input, number));
				}
			} catch (NumberFormatException e) {
				setError(Messages.format(PreferencesMessages.JavaBuildConfigurationBlock_invalid_input, number));
			}
		}
		return this;
	}

	public void generated_8815789725177820272(FavoriteStaticMemberInputDialog favoritestaticmemberinputdialog, String newText) {
		if (newText.length() == 0) {
			setError(""); //$NON-NLS-1$
		} else {
			IStatus val= JavaConventions.validateJavaTypeName(newText, JavaCore.VERSION_1_3, JavaCore.VERSION_1_3);
			if (val.matches(IStatus.ERROR)) {
				if (favoritestaticmemberinputdialog.fIsEditingMember)
					setError(PreferencesMessages.FavoriteStaticMemberInputDialog_error_invalidMemberName);
				else
					setError(PreferencesMessages.FavoriteStaticMemberInputDialog_error_invalidTypeName);
			} else {
				if (favoritestaticmemberinputdialog.doesExist(newText)) {
					setError(PreferencesMessages.FavoriteStaticMemberInputDialog_error_entryExists);
				}
			}
		}
	}

	public boolean generated_3869218788986760585(ImportOrganizeConfigurationBlock importorganizeconfigurationblock) {
		importorganizeconfigurationblock.updateStatus(this);
		return isOK();
	}

	public void generated_2123518839692534937(TypeFilterInputDialog typefilterinputdialog) {
		String newText= typefilterinputdialog.fNameDialogField.getText();
		if (newText.length() == 0) {
			setError(PreferencesMessages.TypeFilterInputDialog_error_enterName);
		} else {
			newText= newText.replace('*', 'X').replace('?', 'Y');
			IStatus val= JavaConventions.validatePackageName(newText, JavaCore.VERSION_1_3, JavaCore.VERSION_1_3);
			if (val.matches(IStatus.ERROR)) {
				setError(Messages.format(PreferencesMessages.TypeFilterInputDialog_error_invalidName, val.getMessage()));
			} else {
				if (typefilterinputdialog.fExistingEntries.contains(newText)) {
					setError(PreferencesMessages.TypeFilterInputDialog_error_entryExists);
				}
			}
		}
	}

	public IStatus generated_4116422634809019126(String val) {
		if (val.length() == 0) {
			return this;
		}
		Path path= new Path(val);
		if (path.isAbsolute()) {
			if (!path.toFile().isDirectory()) {
				setWarning(NewWizardMessages.NativeLibrariesDialog_error_external_not_existing);
				return this;
			}
		} else {
			if (!(ResourcesPlugin.getWorkspace().getRoot().findMember(path) instanceof IContainer)) {
				setWarning(NewWizardMessages.NativeLibrariesDialog_error_internal_not_existing);
				return this;
			}
		}
		return this;
	}

	public IStatus generated_7084452779791600753(JavadocConfigurationBlock javadocconfigurationblock) {
		try {
			String jdocLocation= javadocconfigurationblock.fURLField.getText();
			if (jdocLocation.length() == 0) {
				return this;
			}
			URL url= new URL(jdocLocation);
			if ("file".equals(url.getProtocol())) { //$NON-NLS-1$
				if (url.getFile() == null) {
					setError(PreferencesMessages.JavadocConfigurationBlock_error_notafolder);
					return this;
				}
			}
			javadocconfigurationblock.fURLResult= url;
		} catch (MalformedURLException e) {
			setError(PreferencesMessages.JavadocConfigurationBlock_MalformedURL_error);
			return this;
		}
	
		return this;
	}

	public IStatus generated_8875932454098679827(JavadocConfigurationBlock javadocconfigurationblock, String jdocLocation) throws MalformedURLException {
		if (jdocLocation.length() > 0)  {
			if (!Path.ROOT.isValidPath(jdocLocation)) {
				setError(PreferencesMessages.JavadocConfigurationBlock_error_invalidarchivepath);
				return this;
			}
			if (javadocconfigurationblock.fWorkspaceRadio.isSelected()) {
				IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
				IResource res= root.findMember(new Path(jdocLocation));
				if (res != null) {
					if (!(res instanceof IFile)) {
						setError(PreferencesMessages.JavadocConfigurationBlock_error_archive_not_found_in_workspace);
						return this;
					}
				} else {
					setError(PreferencesMessages.JavadocConfigurationBlock_error_archive_not_found_in_workspace);
					return this;
				}
			} else {
				IPath path= Path.fromOSString(jdocLocation);
				if (!path.isAbsolute()) {
					setError(PreferencesMessages.JavadocConfigurationBlock_error_archivepathnotabsolute);
					return this;
				}
				File jarFile= new File(jdocLocation);
				if (jarFile.isDirectory())  {
					setError(PreferencesMessages.JavadocConfigurationBlock_error_notafile);
					return this;
				}
				if (!jarFile.exists())  {
					setWarning(PreferencesMessages.JavadocConfigurationBlock_error_notafile);
				}
			}
			javadocconfigurationblock.fArchiveURLResult= javadocconfigurationblock.getArchiveURL();
		}
		return this;
	}

	public IStatus generated_2421717078021888208(MalformedURLException e) {
		setError(e.getMessage());
		//status.setError(PreferencesMessages.getString("JavadocConfigurationBlock.MalformedURL.error"));  //$NON-NLS-1$
		return this;
	}

	public void generated_6551968891510580693(NewSourceFolderWizardPage newsourcefolderwizardpage) {
		String str= newsourcefolderwizardpage.fProjectField.getText();
		if (str.length() == 0) {
			setError(NewWizardMessages.NewSourceFolderWizardPage_error_EnterProjectName);
			return;
		}
		IPath path= new Path(str);
		if (path.segmentCount() != 1) {
			setError(NewWizardMessages.NewSourceFolderWizardPage_error_InvalidProjectPath);
			return;
		}
		IProject project= newsourcefolderwizardpage.fWorkspaceRoot.getProject(path.toString());
		if (!project.exists()) {
			setError(NewWizardMessages.NewSourceFolderWizardPage_error_ProjectNotExists);
			return;
		}
		if (!project.isOpen()) {
			setError(NewWizardMessages.NewSourceFolderWizardPage_error_ProjectNotOpen);
			return;
		}
		try {
			if (project.hasNature(JavaCore.NATURE_ID)) {
				newsourcefolderwizardpage.fCurrJProject= JavaCore.create(project);
				newsourcefolderwizardpage.fEntries= newsourcefolderwizardpage.fCurrJProject.getRawClasspath();
				newsourcefolderwizardpage.fOutputLocation= newsourcefolderwizardpage.fCurrJProject.getOutputLocation();
				setOK();
				return;
			}
		} catch (CoreException e) {
			JavaPlugin.log(e);
			newsourcefolderwizardpage.fCurrJProject= null;
		}
		setError(NewWizardMessages.NewSourceFolderWizardPage_error_NotAJavaProject);
	}

	public void generated_8639980978936459268(NewSourceFolderWizardPage newsourcefolderwizardpage) {
		setOK();
	
		IPath projPath= newsourcefolderwizardpage.fCurrJProject.getProject().getFullPath();
		String str= newsourcefolderwizardpage.fRootDialogField.getText();
		if (str.length() == 0) {
			setError(Messages.format(NewWizardMessages.NewSourceFolderWizardPage_error_EnterRootName, BasicElementLabels.getPathLabel(newsourcefolderwizardpage.fCurrJProject.getPath(), false)));
		} else {
			IPath path= projPath.append(str);
			IStatus validate= newsourcefolderwizardpage.fWorkspaceRoot.getWorkspace().validatePath(path.toString(), IResource.FOLDER);
			if (validate.matches(IStatus.ERROR)) {
				setError(Messages.format(NewWizardMessages.NewSourceFolderWizardPage_error_InvalidRootName, validate.getMessage()));
			} else {
				IResource res= newsourcefolderwizardpage.fWorkspaceRoot.findMember(path);
				if (res != null) {
					if (res.getType() != IResource.FOLDER) {
						setError(NewWizardMessages.NewSourceFolderWizardPage_error_NotAFolder);
						return;
					}
					if (res.isVirtual()) {
						setError(NewWizardMessages.NewSourceFolderWizardPage_error_FolderIsVirtual);
						return;
					}
				} else {
					if (!ResourcesPlugin.getWorkspace().validateFiltered(newsourcefolderwizardpage.fWorkspaceRoot.getFolder(path)).isOK()) {
						setError(NewWizardMessages.NewSourceFolderWizardPage_error_FolderNameFiltered);
						return;
					}
					URI projLocation= newsourcefolderwizardpage.fCurrJProject.getProject().getLocationURI();
					if (projLocation != null) {
						try {
							IFileStore store= EFS.getStore(projLocation).getChild(str);
							if (store.fetchInfo().exists()) {
								setError(NewWizardMessages.NewSourceFolderWizardPage_error_AlreadyExistingDifferentCase);
								return;
							}
						} catch (CoreException e) {
							// we couldn't create the file store. Ignore the exception
							// since we can't check if the file exist. Pretend that it
							// doesn't.
						}
					}
				}
				ArrayList<IClasspathEntry> newEntries= new ArrayList<IClasspathEntry>(newsourcefolderwizardpage.fEntries.length + 1);
				int projectEntryIndex= -1;
	
				for (int i= 0; i < newsourcefolderwizardpage.fEntries.length; i++) {
					IClasspathEntry curr= newsourcefolderwizardpage.fEntries[i];
					if (curr.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
						if (path.equals(curr.getPath())) {
							setError(NewWizardMessages.NewSourceFolderWizardPage_error_AlreadyExisting);
							return;
						}
						if (projPath.equals(curr.getPath())) {
							projectEntryIndex= i;
						}
					}
					newEntries.add(curr);
				}
	
				IClasspathAttribute[] attributes;
				if (newsourcefolderwizardpage.fIgnoreOptionalProblemsField.isSelected()) {
					attributes= new IClasspathAttribute[] { NewSourceFolderWizardPage.ATTR_IGNORE_OPTIONAL_PROBLEMS_TRUE };
				} else {
					attributes= new IClasspathAttribute[] {};
				}
				IClasspathEntry newEntry= JavaCore.newSourceEntry(path, null, null, null, attributes);
	
				Set<IClasspathEntry> modified= new HashSet<IClasspathEntry>();
				if (newsourcefolderwizardpage.fExcludeInOthersFields.isSelected()) {
					newsourcefolderwizardpage.addExclusionPatterns(newEntry, newEntries, modified);
					IClasspathEntry entry= JavaCore.newSourceEntry(path, null, null, null, attributes);
					newsourcefolderwizardpage.insertAtEndOfCategory(entry, newEntries);
				} else {
					if (projectEntryIndex != -1) {
						newsourcefolderwizardpage.fIsProjectAsSourceFolder= true;
						newEntries.set(projectEntryIndex, newEntry);
					} else {
						IClasspathEntry entry= JavaCore.newSourceEntry(path, null, null, null, attributes);
						newsourcefolderwizardpage.insertAtEndOfCategory(entry, newEntries);
					}
				}
	
				newsourcefolderwizardpage.fNewEntries= newEntries.toArray(new IClasspathEntry[newEntries.size()]);
				newsourcefolderwizardpage.fNewOutputLocation= newsourcefolderwizardpage.fOutputLocation;
	
				IJavaModelStatus status= JavaConventions.validateClasspath(newsourcefolderwizardpage.fCurrJProject, newsourcefolderwizardpage.fNewEntries, newsourcefolderwizardpage.fNewOutputLocation);
				if (!status.isOK()) {
					if (newsourcefolderwizardpage.fOutputLocation.equals(projPath)) {
						newsourcefolderwizardpage.fNewOutputLocation= projPath.append(PreferenceConstants.getPreferenceStore().getString(PreferenceConstants.SRCBIN_BINNAME));
						IStatus status2= JavaConventions.validateClasspath(newsourcefolderwizardpage.fCurrJProject, newsourcefolderwizardpage.fNewEntries, newsourcefolderwizardpage.fNewOutputLocation);
						if (status2.isOK()) {
							if (newsourcefolderwizardpage.fIsProjectAsSourceFolder) {
								setInfo(Messages.format(NewWizardMessages.NewSourceFolderWizardPage_warning_ReplaceSFandOL, BasicElementLabels.getPathLabel(newsourcefolderwizardpage.fNewOutputLocation, false)));
							} else {
								setInfo(Messages.format(NewWizardMessages.NewSourceFolderWizardPage_warning_ReplaceOL, BasicElementLabels.getPathLabel(newsourcefolderwizardpage.fNewOutputLocation, false)));
							}
							return;
						}
					}
					setError(status.getMessage());
					return;
				} else if (newsourcefolderwizardpage.fIsProjectAsSourceFolder) {
					setInfo(NewWizardMessages.NewSourceFolderWizardPage_warning_ReplaceSF);
					return;
				}
				if (!modified.isEmpty()) {
					String info= modified.size() == 1 ? Messages.format(NewWizardMessages.NewSourceFolderWizardPage_warning_AddedExclusions_singular, (modified.iterator().next())
							.getPath()) : Messages.format(NewWizardMessages.NewSourceFolderWizardPage_warning_AddedExclusions_plural, String.valueOf(modified.size()));
					setInfo(info);
					return;
				}
			}
		}
	}

	public boolean generated_6969006136874365073(boolean isValidSelection, boolean canExtend, NewVariableEntryDialog newvariableentrydialog) {
		List<CPVariableElement> selected= newvariableentrydialog.fVariablesList.getSelectedElements();
		int nSelected= selected.size();
	
		if (nSelected > 0) {
			newvariableentrydialog.fResultPaths= new Path[nSelected];
			for (int i= 0; i < nSelected; i++) {
				CPVariableElement curr= selected.get(i);
				newvariableentrydialog.fResultPaths[i]= new Path(curr.getName());
				File file= curr.getPath().toFile();
				if (!file.exists()) {
					setError(NewWizardMessages.NewVariableEntryDialog_info_notexists);
					isValidSelection= false;
					break;
				}
				if (file.isDirectory()) {
					canExtend= true;
				}
			}
		} else {
			isValidSelection= false;
			setInfo(NewWizardMessages.NewVariableEntryDialog_info_noselection);
		}
		if (isValidSelection && nSelected > 1) {
			String str= Messages.format(NewWizardMessages.NewVariableEntryDialog_info_selected, String.valueOf(nSelected));
			setInfo(str);
		}
		newvariableentrydialog.fCanExtend= nSelected == 1 && canExtend;
		return isValidSelection;
	}

	public void generated_5389861987696786622(AccessRuleEntryDialog accessruleentrydialog, String pattern) {
		if (pattern.length() == 0) {
			setError(NewWizardMessages.TypeRestrictionEntryDialog_error_empty);
			return;
		}
		IPath path= new Path(pattern);
		if (path.isAbsolute() || path.getDevice() != null) {
			setError(NewWizardMessages.TypeRestrictionEntryDialog_error_notrelative);
			return;
		}
	
		accessruleentrydialog.fPattern= pattern;
		setOK();
	}

	public void generated_9003560349547791014(BuildPathsBlock buildpathsblock, String text) {
		if ("".equals(text)) { //$NON-NLS-1$
			setError(NewWizardMessages.BuildPathsBlock_error_EnterBuildPath);
			return;
		}
		IPath path= buildpathsblock.getOutputLocation();
		buildpathsblock.fOutputLocationPath= path;
	
		IResource res= buildpathsblock.fWorkspaceRoot.findMember(path);
		if (res != null) {
			// if exists, must be a folder or project
			if (res.getType() == IResource.FILE) {
				setError(NewWizardMessages.BuildPathsBlock_error_InvalidBuildPath);
				return;
			}
		}
	
		setOK();
	
		String pathStr= buildpathsblock.fBuildPathDialogField.getText();
		Path outputPath= (new Path(pathStr));
		pathStr= outputPath.lastSegment();
		if (pathStr.equals(".settings") && outputPath.segmentCount() == 2) { //$NON-NLS-1$
			setWarning(NewWizardMessages.OutputLocation_SettingsAsLocation);
		}
	
		if (pathStr.charAt(0) == '.' && pathStr.length() > 1) {
			setWarning(Messages.format(NewWizardMessages.OutputLocation_DotAsLocation, BasicElementLabels.getResourceName(pathStr)));
		}
	
		buildpathsblock.updateBuildPathStatus();
	}

	public void generated_4722824856299309518(BuildPathsBlock buildpathsblock) {
		List<CPListElement> elements= buildpathsblock.fClassPathList.getElements();
		IClasspathEntry[] entries= new IClasspathEntry[elements.size()];
	
		for (int i= elements.size()-1 ; i >= 0 ; i--) {
			CPListElement currElement= elements.get(i);
			entries[i]= currElement.getClasspathEntry();
		}
	
		IJavaModelStatus status= JavaConventions.validateClasspath(buildpathsblock.fCurrJProject, entries, buildpathsblock.fOutputLocationPath);
		if (!status.isOK()) {
			setError(status.getMessage());
			return;
		}
		setOK();
	}

	public void generated_671000712031234083(ClasspathContainerDefaultPage classpathcontainerdefaultpage, String str) {
		if (str.length() == 0) {
			setError(NewWizardMessages.ClasspathContainerDefaultPage_path_error_enterpath);
		} else if (!Path.ROOT.isValidPath(str)) {
			setError(NewWizardMessages.ClasspathContainerDefaultPage_path_error_invalidpath);
		} else {
			IPath path= new Path(str);
			if (path.segmentCount() == 0) {
				setError(NewWizardMessages.ClasspathContainerDefaultPage_path_error_needssegment);
			} else if (classpathcontainerdefaultpage.fUsedPaths.contains(path)) {
				setError(NewWizardMessages.ClasspathContainerDefaultPage_path_error_alreadyexists);
			}
		}
	}

	public IStatus generated_3320629973234764359(SourceAttachmentBlock sourceattachmentblock, String fileName) {
		if (fileName.length() == 0) {
			// no source attachment
			return this;
		} else {
			if (!Path.EMPTY.isValidPath(fileName)) {
				setError(NewWizardMessages.SourceAttachmentBlock_filename_error_notvalid);
				return this;
			}
			IPath filePath= Path.fromOSString(fileName);
			IPath resolvedPath;
			if (sourceattachmentblock.isVariableEntry()) {
				if (filePath.getDevice() != null) {
					setError(NewWizardMessages.SourceAttachmentBlock_filename_error_deviceinpath);
					return this;
				}
				String varName= filePath.segment(0);
				if (varName == null) {
					setError(NewWizardMessages.SourceAttachmentBlock_filename_error_notvalid);
					return this;
				}
				sourceattachmentblock.fFileVariablePath= JavaCore.getClasspathVariable(varName);
				if (sourceattachmentblock.fFileVariablePath == null) {
					setError(NewWizardMessages.SourceAttachmentBlock_filename_error_varnotexists);
					return this;
				}
				resolvedPath= sourceattachmentblock.fFileVariablePath.append(filePath.removeFirstSegments(1));
	
				if (resolvedPath.isEmpty()) {
					setWarning(NewWizardMessages.SourceAttachmentBlock_filename_warning_varempty);
					return this;
				}
				File file= resolvedPath.toFile();
				if (!file.exists()) {
					String message= Messages.format(NewWizardMessages.SourceAttachmentBlock_filename_error_filenotexists, BasicElementLabels.getPathLabel(resolvedPath, true));
					setWarning(message);
					return this;
				}
				if (!resolvedPath.isAbsolute()) {
					String message=  Messages.format(NewWizardMessages.SourceAttachmentBlock_filename_error_notabsolute, BasicElementLabels.getPathLabel(filePath, false));
					setError(message);
					return this;
				}
	
				String deprecationMessage= BuildPathSupport.getDeprecationMessage(varName);
				if (deprecationMessage != null) {
					setWarning(deprecationMessage);
					return this;
				}
	
			} else {
				// JDT/Core only supports source attachments in archives on the
				// local file system. So using getLocation is save here.
				File file= filePath.toFile();
				IResource res= sourceattachmentblock.fWorkspaceRoot.findMember(filePath);
				if (res != null && res.getLocation() != null) {
					file= res.getLocation().toFile();
				}
				if (!file.exists()) {
					String message=  Messages.format(NewWizardMessages.SourceAttachmentBlock_filename_error_filenotexists, BasicElementLabels.getPathLabel(filePath, false));
					setError(message);
					return this;
				}
				if (res == null) {
					if (!filePath.isAbsolute()) {
						String message=  Messages.format(NewWizardMessages.SourceAttachmentBlock_filename_error_notabsolute, BasicElementLabels.getPathLabel(filePath, false));
						setError(message);
						return this;
					}
				}
			}
	
		}
		return this;
	}

	public void generated_7340645186492419393(NewSourceFolderDialog newsourcefolderdialog) {
		newsourcefolderdialog.fFolder= null;
		IContainer folder= null;
		if (newsourcefolderdialog.fUseFolderButton.isSelected()) {
			String pathStr= newsourcefolderdialog.fContainerDialogField.getText();
			if (pathStr.length() == 0) {
				setError(NewWizardMessages.NewSourceFolderDialog_error_enterpath);
				return;
			}
			IPath path= newsourcefolderdialog.fCurrProject.getFullPath().append(pathStr);
			IWorkspace workspace= newsourcefolderdialog.fCurrProject.getWorkspace();
	
			IStatus pathValidation= workspace.validatePath(path.toString(), IResource.FOLDER);
			if (!pathValidation.isOK()) {
				setError(Messages.format(NewWizardMessages.NewSourceFolderDialog_error_invalidpath, pathValidation.getMessage()));
				return;
			}
			folder= newsourcefolderdialog.fCurrProject.getFolder(pathStr);
		} else {
			folder= newsourcefolderdialog.fCurrProject;
		}
		if (newsourcefolderdialog.isExisting(folder)) {
			setError(NewWizardMessages.NewSourceFolderDialog_error_pathexists);
			return;
		}
		setOK();
		newsourcefolderdialog.fFolder= folder;
	}

	public void generated_683443080356209627(NewContainerDialog newcontainerdialog, String pathStr) {
		if (pathStr.length() == 0) {
			setError(NewWizardMessages.NewContainerDialog_error_enterpath);
			return;
		}
		IPath path= newcontainerdialog.fCurrProject.getFullPath().append(pathStr);
		IWorkspace workspace= newcontainerdialog.fCurrProject.getWorkspace();
	
		IStatus pathValidation= workspace.validatePath(path.toString(), IResource.FOLDER);
		if (!pathValidation.isOK()) {
			setError(Messages.format(NewWizardMessages.NewContainerDialog_error_invalidpath, pathValidation.getMessage()));
			return;
		}
		IFolder folder= newcontainerdialog.fCurrProject.getFolder(pathStr);
		if (newcontainerdialog.isFolderExisting(folder)) {
			setError(NewWizardMessages.NewContainerDialog_error_pathexists);
			return;
		}
		setOK();
		newcontainerdialog.fFolder= folder;
	}

	public StatusInfo generated_3811949559659235490(VariableCreationDialog variablecreationdialog, String name) {
		if (name.length() == 0) {
			setError(NewWizardMessages.VariableCreationDialog_error_entername);
			return this;
		}
		if (name.trim().length() != name.length()) {
			setError(NewWizardMessages.VariableCreationDialog_error_whitespace);
		} else if (!Path.ROOT.isValidSegment(name)) {
			setError(NewWizardMessages.VariableCreationDialog_error_invalidname);
		} else if (variablecreationdialog.nameConflict(name)) {
			setError(NewWizardMessages.VariableCreationDialog_error_nameexists);
		}
		return this;
	}

	public StatusInfo generated_1933544809482677536(String path) {
		if (path.length() > 0) { // empty path is ok
			if (!Path.ROOT.isValidPath(path)) {
				setError(NewWizardMessages.VariableCreationDialog_error_invalidpath);
			} else if (!new File(path).exists()) {
				setWarning(NewWizardMessages.VariableCreationDialog_warning_pathnotexists);
			}
		}
		return this;
	}

	public void generated_5016018090053794507(ExclusionInclusionEntryDialog exclusioninclusionentrydialog, String pattern) {
		if (pattern.length() == 0) {
			setError(NewWizardMessages.ExclusionInclusionEntryDialog_error_empty);
			return;
		}
		IPath path= new Path(pattern);
		if (path.isAbsolute() || path.getDevice() != null) {
			setError(NewWizardMessages.ExclusionInclusionEntryDialog_error_notrelative);
			return;
		}
		if (exclusioninclusionentrydialog.fExistingPatterns.contains(pattern)) {
			setError(NewWizardMessages.ExclusionInclusionEntryDialog_error_exists);
			return;
		}
	
		exclusioninclusionentrydialog.fExclusionPattern= pattern;
		setOK();
	}

	public IStatus generated_9097598671688101024(EditVariableEntryDialog editvariableentrydialog, String fileName) {
		if (fileName.length() == 0) {
			setError(NewWizardMessages.EditVariableEntryDialog_filename_empty);
			return this;
		} else {
			if (!Path.EMPTY.isValidPath(fileName)) {
				setError(NewWizardMessages.EditVariableEntryDialog_filename_error_notvalid);
				return this;
			}
			IPath filePath= Path.fromOSString(fileName);
			IPath resolvedPath;
	
	
			if (filePath.getDevice() != null) {
				setError(NewWizardMessages.EditVariableEntryDialog_filename_error_deviceinpath);
				return this;
			}
			String varName= filePath.segment(0);
			if (varName == null) {
				setError(NewWizardMessages.EditVariableEntryDialog_filename_error_notvalid);
				return this;
			}
			editvariableentrydialog.fFileVariablePath= JavaCore.getClasspathVariable(varName);
			if (editvariableentrydialog.fFileVariablePath == null) {
				setError(NewWizardMessages.EditVariableEntryDialog_filename_error_varnotexists);
				return this;
			}
	
			String deprecationMessage= BuildPathSupport.getDeprecationMessage(varName);
	
			resolvedPath= editvariableentrydialog.fFileVariablePath.append(filePath.removeFirstSegments(1));
			if (resolvedPath.isEmpty()) {
				String message= NewWizardMessages.EditVariableEntryDialog_filename_warning_varempty;
				if (deprecationMessage != null) {
					message= deprecationMessage + "\n" + message; //$NON-NLS-1$
				}
				setWarning(message);
				return this;
			}
			File file= resolvedPath.toFile();
			if (!file.exists()) {
				String message= Messages.format(NewWizardMessages.EditVariableEntryDialog_filename_error_filenotexists, BasicElementLabels.getPathLabel(resolvedPath, true));
				if (deprecationMessage != null) {
					message= deprecationMessage + "\n" + message; //$NON-NLS-1$
					setWarning(message);
				} else {
					setInfo(message);
				}
				return this;
			}
			if (deprecationMessage != null) {
				setWarning(deprecationMessage);
				return this;
			}
		}
		return this;
	}

	public StatusInfo generated_2551826335379734895(IJavaProject javaProject, AddSourceFolderWizardPage addsourcefolderwizardpage, IPath projPath, IPath path, int projectEntryIndex) {
		boolean createFolderForExisting= false;
	
		IFolder folder= addsourcefolderwizardpage.fParent.getFolder(new Path(addsourcefolderwizardpage.fRootDialogField.getText()));
		for (int i= 0; i < addsourcefolderwizardpage.fExistingEntries.size(); i++) {
			IClasspathEntry curr= addsourcefolderwizardpage.fExistingEntries.get(i).getClasspathEntry();
			if (curr.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
				if (path.equals(curr.getPath()) && addsourcefolderwizardpage.fExistingEntries.get(i) != addsourcefolderwizardpage.fNewElement) {
					if (folder.exists()) {
						setError(NewWizardMessages.NewSourceFolderWizardPage_error_AlreadyExisting);
						return this;
					} else {
						createFolderForExisting= true;
					}
				}
				if (projPath.equals(curr.getPath())) {
					projectEntryIndex= i;
				}
			}
		}
	
		if (folder.exists() && !folder.getFullPath().equals(addsourcefolderwizardpage.fOrginalPath))
			return new StatusInfo(IStatus.ERROR, Messages.format(NewWizardMessages.NewFolderDialog_folderNameEmpty_alreadyExists, BasicElementLabels.getPathLabel(folder.getFullPath(), false)));
	
		boolean isProjectASourceFolder= projectEntryIndex != -1;
	
		addsourcefolderwizardpage.fModifiedElements.clear();
		addsourcefolderwizardpage.updateFilters(addsourcefolderwizardpage.fNewElement.getPath(), path);
	
		addsourcefolderwizardpage.fNewElement.setPath(path);
		if (addsourcefolderwizardpage.fLinkedMode) {
			addsourcefolderwizardpage.fNewElement.setLinkTarget(addsourcefolderwizardpage.fLinkFields.getLinkTarget());
		}
		addsourcefolderwizardpage.fRemovedElements.clear();
		Set<CPListElement> modified= new HashSet<CPListElement>();
		boolean isProjectSourceFolderReplaced= false;
		if (addsourcefolderwizardpage.fAddExclusionPatterns.isSelected()) {
			if (addsourcefolderwizardpage.fOrginalPath == null) {
				addsourcefolderwizardpage.addExclusionPatterns(addsourcefolderwizardpage.fNewElement, addsourcefolderwizardpage.fExistingEntries, modified);
				addsourcefolderwizardpage.fModifiedElements.addAll(modified);
				if (!createFolderForExisting)
					CPListElement.insert(addsourcefolderwizardpage.fNewElement, addsourcefolderwizardpage.fExistingEntries);
			}
		} else {
			if (isProjectASourceFolder) {
				if (addsourcefolderwizardpage.fRemoveProjectFolder.isSelected()) {
					addsourcefolderwizardpage.fOldProjectSourceFolder= addsourcefolderwizardpage.fExistingEntries.get(projectEntryIndex);
					addsourcefolderwizardpage.fRemovedElements.add(addsourcefolderwizardpage.fOldProjectSourceFolder);
					addsourcefolderwizardpage.fExistingEntries.set(projectEntryIndex, addsourcefolderwizardpage.fNewElement);
					isProjectSourceFolderReplaced= true;
				} else {
					if (!createFolderForExisting)
					CPListElement.insert(addsourcefolderwizardpage.fNewElement, addsourcefolderwizardpage.fExistingEntries);
				}
			} else {
				if (!createFolderForExisting)
					CPListElement.insert(addsourcefolderwizardpage.fNewElement, addsourcefolderwizardpage.fExistingEntries);
			}
		}
	
		if ((!addsourcefolderwizardpage.fAllowConflict && addsourcefolderwizardpage.fCanCommitConflictingBuildpath) || createFolderForExisting)
			return new StatusInfo();
	
		addsourcefolderwizardpage.fNewOutputLocation= null;
		IJavaModelStatus status= JavaConventions.validateClasspath(javaProject, CPListElement.convertToClasspathEntries(addsourcefolderwizardpage.fExistingEntries), addsourcefolderwizardpage.fOutputLocation);
		if (!status.isOK()) {
			if (addsourcefolderwizardpage.fOutputLocation.equals(projPath)) {
				//Try to change the output folder
				addsourcefolderwizardpage.fNewOutputLocation= projPath.append(PreferenceConstants.getPreferenceStore().getString(PreferenceConstants.SRCBIN_BINNAME));
				IStatus status2= JavaConventions.validateClasspath(javaProject, CPListElement.convertToClasspathEntries(addsourcefolderwizardpage.fExistingEntries), addsourcefolderwizardpage.fNewOutputLocation);
				if (status2.isOK()) {
					if (isProjectSourceFolderReplaced) {
						setInfo(Messages.format(NewWizardMessages.NewSourceFolderWizardPage_warning_ReplaceSFandOL, BasicElementLabels.getPathLabel(addsourcefolderwizardpage.fNewOutputLocation, false)));
					} else {
						setInfo(Messages.format(NewWizardMessages.NewSourceFolderWizardPage_warning_ReplaceOL, BasicElementLabels.getPathLabel(addsourcefolderwizardpage.fNewOutputLocation, false)));
					}
					return this;
				}
			}
			//Don't know what the problem is, report to user
			addsourcefolderwizardpage.fNewOutputLocation= null;
			if (addsourcefolderwizardpage.fCanCommitConflictingBuildpath) {
				setInfo(NewWizardMessages.AddSourceFolderWizardPage_conflictWarning + status.getMessage());
			} else {
				setError(status.getMessage());
			}
			return this;
		}
		if (!modified.isEmpty()) {
			//Added exclusion patterns to solve problem
			if (modified.size() == 1) {
				CPListElement elem= (CPListElement)modified.toArray()[0];
				String changed= BasicElementLabels.getPathLabel(elem.getPath(), false);
				String excl= BasicElementLabels.getPathLabel(addsourcefolderwizardpage.fNewElement.getPath(), false);
				setInfo(Messages.format(NewWizardMessages.AddSourceFolderWizardPage_addSinglePattern, new Object[] {excl, changed}));
			} else {
				setInfo(Messages.format(NewWizardMessages.NewSourceFolderWizardPage_warning_AddedExclusions_plural, String.valueOf(modified.size())));
			}
			return this;
		}
		if (isProjectSourceFolderReplaced) {
			setInfo(NewWizardMessages.AddSourceFolderWizardPage_replaceSourceFolderInfo);
			return this;
		}
	
		return this;
	}

	public void generated_8792137329388506661() throws CoreException {
		setError(NewWizardMessages.ClasspathModifier_Error_NoNatures);
		throw new CoreException(this);
	}

	public void generated_6530786110144286140(NewElementWizardPage newelementwizardpage) {
		setError("");  //$NON-NLS-1$
		newelementwizardpage.fCurrStatus= this;
	}

	public IStatus generated_1936382759706378607(NewContainerWizardPage newcontainerwizardpage, String str) {
		if (str.length() == 0) {
			setError(NewWizardMessages.NewContainerWizardPage_error_EnterContainerName);
			return this;
		}
		IPath path= new Path(str);
		IResource res= newcontainerwizardpage.fWorkspaceRoot.findMember(path);
		if (res != null) {
			int resType= res.getType();
			if (resType == IResource.PROJECT || resType == IResource.FOLDER) {
				IProject proj= res.getProject();
				if (!proj.isOpen()) {
					setError(Messages.format(NewWizardMessages.NewContainerWizardPage_error_ProjectClosed, BasicElementLabels.getPathLabel(proj.getFullPath(), false)));
					return this;
				}
				IJavaProject jproject= JavaCore.create(proj);
				newcontainerwizardpage.fCurrRoot= jproject.getPackageFragmentRoot(res);
				if (res.exists()) {
					if (res.isVirtual()) {
						setError(NewWizardMessages.NewContainerWizardPage_error_FolderIsVirtual);
						return this;
					}
					try {
						if (!proj.hasNature(JavaCore.NATURE_ID)) {
							if (resType == IResource.PROJECT) {
								setError(NewWizardMessages.NewContainerWizardPage_warning_NotAJavaProject);
							} else {
								setWarning(NewWizardMessages.NewContainerWizardPage_warning_NotInAJavaProject);
							}
							return this;
						}
						if (newcontainerwizardpage.fCurrRoot.isArchive()) {
							setError(Messages.format(NewWizardMessages.NewContainerWizardPage_error_ContainerIsBinary, BasicElementLabels.getPathLabel(path, false)));
							return this;
						}
						if (newcontainerwizardpage.fCurrRoot.getKind() == IPackageFragmentRoot.K_BINARY) {
							setWarning(Messages.format(NewWizardMessages.NewContainerWizardPage_warning_inside_classfolder, BasicElementLabels.getPathLabel(path, false)));
						} else if (!jproject.isOnClasspath(newcontainerwizardpage.fCurrRoot)) {
							setWarning(Messages.format(NewWizardMessages.NewContainerWizardPage_warning_NotOnClassPath, BasicElementLabels.getPathLabel(path, false)));
						}
					} catch (JavaModelException e) {
						setWarning(NewWizardMessages.NewContainerWizardPage_warning_NotOnClassPath);
					} catch (CoreException e) {
						setWarning(NewWizardMessages.NewContainerWizardPage_warning_NotAJavaProject);
					}
				}
				return this;
			} else {
				setError(Messages.format(NewWizardMessages.NewContainerWizardPage_error_NotAFolder, BasicElementLabels.getPathLabel(path, false)));
				return this;
			}
		} else {
			setError(Messages.format(NewWizardMessages.NewContainerWizardPage_error_ContainerDoesNotExist, BasicElementLabels.getPathLabel(path, false)));
			return this;
		}
	}

	public IStatus generated_1429417320186001881(NewTypeWizardPage newtypewizardpage) {
		IPackageFragmentRoot root= newtypewizardpage.getPackageFragmentRoot();
		newtypewizardpage.fPackageDialogField.enableButton(root != null);
	
		IJavaProject project= root != null ? root.getJavaProject() : null;
	
		String packName= newtypewizardpage.getPackageText();
		if (packName.length() > 0) {
			IStatus val= NewTypeWizardPage.validatePackageName(packName, project);
			if (val.getSeverity() == IStatus.ERROR) {
				setError(Messages.format(NewWizardMessages.NewTypeWizardPage_error_InvalidPackageName, val.getMessage()));
				return this;
			} else if (val.getSeverity() == IStatus.WARNING) {
				setWarning(Messages.format(NewWizardMessages.NewTypeWizardPage_warning_DiscouragedPackageName, val.getMessage()));
				// continue
			}
		} else {
			setWarning(NewWizardMessages.NewTypeWizardPage_warning_DefaultPackageDiscouraged);
		}
	
		if (project != null) {
			if (project.exists() && packName.length() > 0) {
				try {
					IPath rootPath= root.getPath();
					IPath outputPath= project.getOutputLocation();
					if (rootPath.isPrefixOf(outputPath) && !rootPath.equals(outputPath)) {
						// if the bin folder is inside of our root, don't allow to name a package
						// like the bin folder
						IPath packagePath= rootPath.append(packName.replace('.', '/'));
						if (outputPath.isPrefixOf(packagePath)) {
							setError(NewWizardMessages.NewTypeWizardPage_error_ClashOutputLocation);
							return this;
						}
					}
				} catch (JavaModelException e) {
					JavaPlugin.log(e);
					// let pass
				}
			}
	
			newtypewizardpage.fCurrPackage= root.getPackageFragment(packName);
			IResource resource= newtypewizardpage.fCurrPackage.getResource();
			if (resource != null){
				if (resource.isVirtual()){
					setError(NewWizardMessages.NewTypeWizardPage_error_PackageIsVirtual);
					return this;
				}			
				if (!ResourcesPlugin.getWorkspace().validateFiltered(resource).isOK()) {
					setError(NewWizardMessages.NewTypeWizardPage_error_PackageNameFiltered);
					return this;
				}
			}
		} else {
			setError(""); //$NON-NLS-1$
		}
		return this;
	}

	public IStatus generated_1881670470749155116() {
		setError(""); //$NON-NLS-1$
		return this;
	}

	public IStatus generated_4559436795639320427(String typeNameWithParameters, String typeName, IJavaProject project) {
		if (!typeNameWithParameters.equals(typeName) && project != null) {
			if (!JavaModelUtil.is50OrHigher(project)) {
				setError(NewWizardMessages.NewTypeWizardPage_error_TypeParameters);
				return this;
			}
			String typeDeclaration= "class " + typeNameWithParameters + " {}"; //$NON-NLS-1$//$NON-NLS-2$
			ASTParser parser= ASTParser.newParser(ASTProvider.SHARED_AST_LEVEL);
			parser.setSource(typeDeclaration.toCharArray());
			parser.setProject(project);
			CompilationUnit compilationUnit= (CompilationUnit) parser.createAST(null);
			IProblem[] problems= compilationUnit.getProblems();
			if (problems.length > 0) {
				setError(Messages.format(NewWizardMessages.NewTypeWizardPage_error_InvalidTypeName, problems[0].getMessage()));
				return this;
			}
		}
		return this;
	}

	public IStatus generated_3206039554864158094(IPackageFragmentRoot root, String sclassName) {
		if (sclassName.length() == 0) {
			// accept the empty field (stands for java.lang.Object)
			return this;
		}
	
		if (root != null) {
			Type type= TypeContextChecker.parseSuperClass(sclassName);
			if (type == null) {
				setError(NewWizardMessages.NewTypeWizardPage_error_InvalidSuperClassName);
				return this;
			}
			if (type instanceof ParameterizedType && ! JavaModelUtil.is50OrHigher(root.getJavaProject())) {
				setError(NewWizardMessages.NewTypeWizardPage_error_SuperClassNotParameterized);
				return this;
			}
		} else {
			setError(""); //$NON-NLS-1$
		}
		return this;
	}

	public IStatus generated_6833489594346951861(NewTypeWizardPage newtypewizardpage, IPackageFragmentRoot root) {
		if (root != null) {
			List<InterfaceWrapper> elements= newtypewizardpage.fSuperInterfacesDialogField.getElements();
			int nElements= elements.size();
			for (int i= 0; i < nElements; i++) {
				String intfname= elements.get(i).interfaceName;
				Type type= TypeContextChecker.parseSuperInterface(intfname);
				if (type == null) {
					setError(Messages.format(NewWizardMessages.NewTypeWizardPage_error_InvalidSuperInterfaceName, BasicElementLabels.getJavaElementName(intfname)));
					return this;
				}
				if (type instanceof ParameterizedType && ! JavaModelUtil.is50OrHigher(root.getJavaProject())) {
					setError(Messages.format(NewWizardMessages.NewTypeWizardPage_error_SuperInterfaceNotParameterized, BasicElementLabels.getJavaElementName(intfname)));
					return this;
				}
			}
		}
		return this;
	}

	public IStatus generated_5181987537003680498(NewTypeWizardPage newtypewizardpage) {
		int modifiers= newtypewizardpage.getModifiers();
		if (Flags.isFinal(modifiers) && Flags.isAbstract(modifiers)) {
			setError(NewWizardMessages.NewTypeWizardPage_error_ModifiersFinalAndAbstract);
		}
		return this;
	}

	public void generated_700241883069130654(IPackageFragment pack) throws JavaModelException {
		if (pack.containsJavaResources() || !pack.hasSubpackages()) {
			setError(NewWizardMessages.NewPackageWizardPage_error_PackageExists);
		} else {
			setError(NewWizardMessages.NewPackageWizardPage_error_PackageNotShown);
		}
	}

	public IStatus generated_8038334573168158399(ConvertIterableLoopOperation convertiterableloopoperation, Expression expression) {
		if (!(expression instanceof MethodInvocation))
			return this;
	
		MethodInvocation invoc= (MethodInvocation)expression;
		IMethodBinding methodBinding= invoc.resolveMethodBinding();
		if (methodBinding == null)
			return ConvertLoopOperation.ERROR_STATUS;
	
		ITypeBinding declaringClass= methodBinding.getDeclaringClass();
		if (declaringClass == null)
			return ConvertLoopOperation.ERROR_STATUS;
	
		String qualifiedName= declaringClass.getQualifiedName();
		String methodName= invoc.getName().getIdentifier();
		if (qualifiedName.startsWith("java.util.Enumeration")) { //$NON-NLS-1$
			if (!methodName.equals("hasMoreElements")) //$NON-NLS-1$
				return this;
		} else if (qualifiedName.startsWith("java.util.Iterator")) { //$NON-NLS-1$
			if (!methodName.equals("hasNext")) //$NON-NLS-1$
				return this;
			return convertiterableloopoperation.checkIteratorCondition();
		} else {
			return this;
		}
	
		return StatusInfo.OK_STATUS;
	}

	public IStatus generated_7916279993924113081(List<Expression> initializers) {
		if (initializers.size() != 1)
			return this;
	
		Expression expression= initializers.get(0);
		if (!(expression instanceof VariableDeclarationExpression))
			return this;
	
		VariableDeclarationExpression declaration= (VariableDeclarationExpression)expression;
		List<VariableDeclarationFragment> variableDeclarationFragments= declaration.fragments();
		if (variableDeclarationFragments.size() != 1)
			return this;
	
		VariableDeclarationFragment declarationFragment= variableDeclarationFragments.get(0);
	
		Expression initializer= declarationFragment.getInitializer();
		if (!(initializer instanceof MethodInvocation))
			return this;
	
		MethodInvocation methodInvocation= (MethodInvocation)initializer;
		String methodName= methodInvocation.getName().getIdentifier();
		if (!"iterator".equals(methodName)) //$NON-NLS-1$
			return this;
		
		return StatusInfo.OK_STATUS;
	}
}