/**
 * {@inheritDoc}
 */
@Override
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
	CompilationUnit compilationUnit= context.getAST();
	if (compilationUnit == null)
		return null;

	boolean addFinal= isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL);
	if (!addFinal)
		return null;

	return VariableDeclarationFix.createCleanUp(compilationUnit,
			isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS),
			isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS),
			isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES));
}
 

/**
 * {@inheritDoc}
 */
@Override
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
	ICompilationUnit compilationUnit= context.getCompilationUnit();
	if (compilationUnit == null)
		return null;

	IRegion[] regions;
	if (context instanceof MultiLineCleanUpContext) {
		regions= ((MultiLineCleanUpContext)context).getRegions();
	} else {
		regions= null;
	}

	boolean removeWhitespaces= isEnabled(CleanUpConstants.FORMAT_REMOVE_TRAILING_WHITESPACES);
	return CodeFormatFix.createCleanUp(compilationUnit,
			regions,
			isEnabled(CleanUpConstants.FORMAT_SOURCE_CODE),
			removeWhitespaces && isEnabled(CleanUpConstants.FORMAT_REMOVE_TRAILING_WHITESPACES_ALL),
			removeWhitespaces && isEnabled(CleanUpConstants.FORMAT_REMOVE_TRAILING_WHITESPACES_IGNORE_EMPTY),
			isEnabled(CleanUpConstants.FORMAT_CORRECT_INDENTATION));
}
 

/**
 * {@inheritDoc}
 */
@Override
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
	CompilationUnit compilationUnit= context.getAST();
	if (compilationUnit == null)
		return null;

	boolean sortMembers= isEnabled(CleanUpConstants.SORT_MEMBERS);
	ICleanUpFix fix= SortMembersFix.createCleanUp(compilationUnit, sortMembers, sortMembers && isEnabled(CleanUpConstants.SORT_MEMBERS_ALL));
	if (fix != null) {
		if (fTouchedFiles == null) {
			fTouchedFiles= new HashSet<IResource>();
		}
		fTouchedFiles.add(((ICompilationUnit)compilationUnit.getJavaElement()).getResource());
	}
	return fix;
}
 

/**
 * {@inheritDoc}
 */
@Override
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
	CompilationUnit compilationUnit= context.getAST();
	if (compilationUnit == null)
		return null;

	boolean useBlocks= isEnabled(CleanUpConstants.CONTROL_STATEMENTS_USE_BLOCKS);
	if (!useBlocks)
		return null;

	return ControlStatementsFix.createCleanUp(compilationUnit,
			isEnabled(CleanUpConstants.CONTROL_STATMENTS_USE_BLOCKS_ALWAYS),
			isEnabled(CleanUpConstants.CONTROL_STATMENTS_USE_BLOCKS_NEVER),
			isEnabled(CleanUpConstants.CONTROL_STATMENTS_USE_BLOCKS_NO_FOR_RETURN_AND_THROW));
}
 

/**
 * {@inheritDoc}
 */
@Override
public ICleanUpFix createFix(final CleanUpContext cleanUpCtx) throws CoreException {
	final CompilationUnit compilationUnit = cleanUpCtx.getAST();
	ICleanUpFix fix = null;
	if (compilationUnit != null) {
		fix = CopyrightFix.createCleanUp(compilationUnit,
				options.isEnabled(CopyrightConstants.CLEANUP_ADD_COPYRIGHTS),
				options.isEnabled(CopyrightConstants.CLEANUP_OVERRIDE_COPYRIGHTS));
	}
	return fix;
}
 

private ICleanUp[] calculateSolutions(CleanUpContext context, ICleanUp[] cleanUps) {
	List<ICleanUp>result= new ArrayList<ICleanUp>();
	CleanUpChange solution;
	try {
		solution= calculateChange(context, cleanUps, result, null);
	} catch (CoreException e) {
		throw new FixCalculationException(e);
	}

	if (solution != null) {
		integrateSolution(solution, context.getCompilationUnit());
	}

	return result.toArray(new ICleanUp[result.size()]);
}
 

/**
 * {@inheritDoc}
 */
@Override
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
	CompilationUnit compilationUnit= context.getAST();
	if (compilationUnit == null)
		return null;

	boolean usePrentheses= isEnabled(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES);
	if (!usePrentheses)
		return null;

	return ExpressionsFix.createCleanUp(compilationUnit,
			isEnabled(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_ALWAYS),
			isEnabled(CleanUpConstants.EXPRESSIONS_USE_PARENTHESES_NEVER));
}
 

/**
 * {@inheritDoc}
 */
@Override
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
	CompilationUnit compilationUnit= context.getAST();
	if (compilationUnit == null)
		return null;

	boolean convertFunctionalInterfaces= isEnabled(CleanUpConstants.CONVERT_FUNCTIONAL_INTERFACES);
	if (!convertFunctionalInterfaces)
		return null;

	return LambdaExpressionsFix.createCleanUp(compilationUnit,
			isEnabled(CleanUpConstants.USE_LAMBDA),
			isEnabled(CleanUpConstants.USE_ANONYMOUS_CLASS_CREATION));
}
 

/**
 * {@inheritDoc}
 */
@Override
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
	CompilationUnit compilationUnit= context.getAST();
	if (compilationUnit == null)
		return null;

	boolean convertForLoops= isEnabled(CleanUpConstants.CONTROL_STATMENTS_CONVERT_FOR_LOOP_TO_ENHANCED);

	return ConvertLoopFix.createCleanUp(compilationUnit,
			convertForLoops, convertForLoops,
			isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL) && isEnabled(CleanUpConstants.VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES));
}
 

/**
    * {@inheritDoc}
    */
   @Override
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
   	CompilationUnit compilationUnit= context.getAST();
   	if (compilationUnit == null)
   		return null;

	return ImportsFix.createCleanUp(compilationUnit, fCodeGeneratorSettings,
			isEnabled(CleanUpConstants.ORGANIZE_IMPORTS), fStatus);
}
 

@Override
public final ICleanUpFix createFix(CleanUpContext context) throws CoreException {
	CompilationUnit unit= context.getAST();
	if (unit == null)
		return null;

	if (context instanceof MultiFixContext) {
		return createFix(unit, ((MultiFixContext)context).getProblemLocations());
	} else {
		return createFix(unit);
	}
}
 

/**
 * {@inheritDoc}
 */
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
	if (!fOptions.isEnabled(UPDATE_IBM_COPYRIGHT_TO_CURRENT_YEAR))
		return null;
	
	return UpdateCopyrightFix.createCleanUp(context.getCompilationUnit(), true);
}
 

public static CleanUpChange calculateChange(CleanUpContext context, ICleanUp[] cleanUps, List<ICleanUp> undoneCleanUps, HashSet<ICleanUp> slowCleanUps) throws CoreException {
	if (cleanUps.length == 0)
		return null;

	CleanUpChange solution= null;
	int i= 0;
	do {
		ICleanUp cleanUp= cleanUps[i];
		ICleanUpFix fix;
		if (slowCleanUps != null) {
			long timeBefore= System.currentTimeMillis();
			fix= cleanUp.createFix(context);
			if (System.currentTimeMillis() - timeBefore > SLOW_CLEAN_UP_THRESHOLD)
				slowCleanUps.add(cleanUp);
		} else {
			fix= cleanUp.createFix(context);
		}
		if (fix != null) {
			CompilationUnitChange current= fix.createChange(null);
			TextEdit currentEdit= current.getEdit();

			if (solution != null) {
				if (TextEditUtil.overlaps(currentEdit, solution.getEdit())) {
					undoneCleanUps.add(cleanUp);
				} else {
					CleanUpChange merge= new CleanUpChange(FixMessages.CleanUpRefactoring_clean_up_multi_chang_name, context.getCompilationUnit());
					merge.setEdit(TextEditUtil.merge(currentEdit, solution.getEdit()));

					copyChangeGroups(merge, solution);
					copyChangeGroups(merge, current);

					solution= merge;
				}
			} else {
				solution= new CleanUpChange(current.getName(), context.getCompilationUnit());
				solution.setEdit(currentEdit);

				copyChangeGroups(solution, current);
			}
		}
		i++;
	} while (i < cleanUps.length && (context.getAST() == null || !cleanUps[i].getRequirements().requiresFreshAST()));

	for (; i < cleanUps.length; i++) {
		undoneCleanUps.add(cleanUps[i]);
	}
	return solution;
}
 

public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
	return null;
}