0001: /*******************************************************************************
0002: * Copyright (c) 2000, 2007 IBM Corporation and others.
0003: * All rights reserved. This program and the accompanying materials
0004: * are made available under the terms of the Eclipse Public License v1.0
0005: * which accompanies this distribution, and is available at
0006: * http://www.eclipse.org/legal/epl-v10.html
0007: *
0008: * Contributors:
0009: * IBM Corporation - initial API and implementation
0010: * Alex Blewitt - https://bugs.eclipse.org/bugs/show_bug.cgi?id=168954
0011: *******************************************************************************/package org.eclipse.jdt.internal.corext.fix;
0012:
0013: import java.util.HashMap;
0014: import java.util.Iterator;
0015: import java.util.Map;
0016:
0017: import org.eclipse.jface.preference.IPreferenceStore;
0018:
0019: import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
0020:
0021: import org.eclipse.jdt.internal.ui.preferences.cleanup.CleanUpProfileVersioner;
0022:
0023: public class CleanUpConstants {
0024:
0025: /**
0026: * False value
0027: *
0028: * @since 3.3
0029: */
0030: public static final String FALSE = "false"; //$NON-NLS-1$
0031:
0032: /**
0033: * True value
0034: *
0035: * @since 3.3
0036: */
0037: public static final String TRUE = "true"; //$NON-NLS-1$
0038:
0039: /**
0040: * Format Java Source Code <br>
0041: * <br>
0042: * Possible values: {TRUE, FALSE}<br>
0043: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0044: * <br>
0045: *
0046: * @see #TRUE
0047: * @see #FALSE
0048: * @since 3.3
0049: */
0050: public static final String FORMAT_SOURCE_CODE = "cleanup.format_source_code"; //$NON-NLS-1$
0051:
0052: /**
0053: * Format comments. Specify which comment with:<br>
0054: * {@link #FORMAT_JAVADOC}<br>
0055: * {@link #FORMAT_MULTI_LINE_COMMENT}<br>
0056: * {@link #FORMAT_SINGLE_LINE_COMMENT} <br>
0057: * <br>
0058: * Possible values: {TRUE, FALSE}<br>
0059: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0060: * <br>
0061: *
0062: * @see #TRUE
0063: * @see #FALSE
0064: * @since 3.3
0065: * @deprecated replaced by {@link #FORMAT_SOURCE_CODE}
0066: */
0067: public static final String FORMAT_COMMENT = "cleanup.format_comment"; //$NON-NLS-1$
0068:
0069: /**
0070: * Format single line comments. Only has an effect if
0071: * {@link #FORMAT_COMMENT} is TRUE <br>
0072: * <br>
0073: * Possible values: {TRUE, FALSE}<br>
0074: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0075: * <br>
0076: *
0077: * @see #TRUE
0078: * @see #FALSE
0079: * @since 3.3
0080: * @deprecated replaced by {@link DefaultCodeFormatterConstants#FORMATTER_COMMENT_FORMAT_LINE_COMMENT}
0081: */
0082: public static final String FORMAT_SINGLE_LINE_COMMENT = "cleanup.format_single_line_comment"; //$NON-NLS-1$
0083:
0084: /**
0085: * Format multi line comments. Only has an effect if {@link #FORMAT_COMMENT}
0086: * is TRUE <br>
0087: * <br>
0088: * Possible values: {TRUE, FALSE}<br>
0089: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0090: * <br>
0091: *
0092: * @see #TRUE
0093: * @see #FALSE
0094: * @since 3.3
0095: * @deprecated replaced by {@link DefaultCodeFormatterConstants#FORMATTER_COMMENT_FORMAT_BLOCK_COMMENT}
0096: */
0097: public static final String FORMAT_MULTI_LINE_COMMENT = "cleanup.format_multi_line_comment"; //$NON-NLS-1$
0098:
0099: /**
0100: * Format javadoc comments. Only has an effect if {@link #FORMAT_COMMENT} is
0101: * TRUE <br>
0102: * <br>
0103: * Possible values: {TRUE, FALSE}<br>
0104: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0105: * <br>
0106: *
0107: * @see #TRUE
0108: * @see #FALSE
0109: * @since 3.3
0110: * @deprecated replaced by {@link DefaultCodeFormatterConstants#FORMATTER_COMMENT_FORMAT_JAVADOC_COMMENT}
0111: */
0112: public static final String FORMAT_JAVADOC = "cleanup.format_javadoc"; //$NON-NLS-1$
0113:
0114: /**
0115: * Removes trailing whitespace in compilation units<br>
0116: * <br>
0117: * Possible values: {TRUE, FALSE}<br>
0118: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0119: * <br>
0120: *
0121: * @see #TRUE
0122: * @see #FALSE
0123: * @since 3.3
0124: */
0125: public static final String FORMAT_REMOVE_TRAILING_WHITESPACES = "cleanup.remove_trailing_whitespaces"; //$NON-NLS-1$
0126:
0127: /**
0128: * Removes trailing whitespace in compilation units on all lines<br>
0129: * Only has an effect if {@link #FORMAT_REMOVE_TRAILING_WHITESPACES} is TRUE
0130: * <br>
0131: * <br>
0132: * Possible values: {TRUE, FALSE}<br>
0133: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0134: * <br>
0135: *
0136: * @see #TRUE
0137: * @see #FALSE
0138: * @since 3.3
0139: */
0140: public static final String FORMAT_REMOVE_TRAILING_WHITESPACES_ALL = "cleanup.remove_trailing_whitespaces_all"; //$NON-NLS-1$
0141:
0142: /**
0143: * Removes trailing whitespace in compilation units on all lines which
0144: * contain an other characters then whitespace<br>
0145: * Only has an effect if {@link #FORMAT_REMOVE_TRAILING_WHITESPACES} is TRUE
0146: * <br>
0147: * <br>
0148: * Possible values: {TRUE, FALSE}<br>
0149: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0150: * <br>
0151: *
0152: * @see #TRUE
0153: * @see #FALSE
0154: * @since 3.3
0155: */
0156: public static final String FORMAT_REMOVE_TRAILING_WHITESPACES_IGNORE_EMPTY = "cleanup.remove_trailing_whitespaces_ignore_empty"; //$NON-NLS-1$
0157:
0158: /**
0159: * Correct indentation in compilation units on all lines
0160: * <br>
0161: * <br>
0162: * Possible values: {TRUE, FALSE}<br>
0163: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0164: * <br>
0165: *
0166: * @see #TRUE
0167: * @see #FALSE
0168: * @since 3.4
0169: */
0170: public static final String FORMAT_CORRECT_INDENTATION = "cleanup.correct_indentation"; //$NON-NLS-1$
0171:
0172: /**
0173: * Controls access qualifiers for instance fields. For detailed settings use<br>
0174: * {@link #MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS_ALWAYS}<br>
0175: * {@link #MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS_IF_NECESSARY} <br>
0176: * <br>
0177: * Possible values: {TRUE, FALSE}<br>
0178: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0179: * <br>
0180: *
0181: * @see #TRUE
0182: * @see #FALSE
0183: * @since 3.3
0184: */
0185: public static final String MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS = "cleanup.use_this_for_non_static_field_access"; //$NON-NLS-1$
0186:
0187: /**
0188: * Adds a 'this' qualifier to field accesses.
0189: * <p>
0190: * i.e.:
0191: *
0192: * <pre><code>
0193: * int fField;
0194: * void foo() {fField= 10;} -> void foo() {this.fField= 10;}
0195: * </pre></code> <br>
0196: * Only has an effect if {@link #MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS}
0197: * is TRUE <br>
0198: * <br>
0199: * Possible values: {TRUE, FALSE}<br>
0200: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0201: * <br>
0202: *
0203: * @see #TRUE
0204: * @see #FALSE
0205: * @since 3.3
0206: */
0207: public static final String MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS_ALWAYS = "cleanup.always_use_this_for_non_static_field_access"; //$NON-NLS-1$
0208:
0209: /**
0210: * Removes 'this' qualifier to field accesses.
0211: * <p>
0212: * i.e.:
0213: *
0214: * <pre><code>
0215: * int fField;
0216: * void foo() {this.fField= 10;} -> void foo() {fField= 10;}
0217: * </pre></code> <br>
0218: * Only has an effect if {@link #MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS}
0219: * is TRUE <br>
0220: * <br>
0221: * Possible values: {TRUE, FALSE}<br>
0222: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0223: * <br>
0224: *
0225: * @see #TRUE
0226: * @see #FALSE
0227: * @since 3.3
0228: */
0229: public static final String MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS_IF_NECESSARY = "cleanup.use_this_for_non_static_field_access_only_if_necessary"; //$NON-NLS-1$
0230:
0231: /**
0232: * Controls access qualifiers for instance methods. For detailed settings
0233: * use<br>
0234: * {@link #MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS_ALWAYS}<br>
0235: * {@link #MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS_IF_NECESSARY} <br>
0236: * <br>
0237: * Possible values: {TRUE, FALSE}<br>
0238: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0239: * <br>
0240: *
0241: * @see #TRUE
0242: * @see #FALSE
0243: * @since 3.3
0244: */
0245: public static final String MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS = "cleanup.use_this_for_non_static_method_access"; //$NON-NLS-1$
0246:
0247: /**
0248: * Adds a 'this' qualifier to method accesses.
0249: * <p>
0250: * i.e.:
0251: *
0252: * <pre><code>
0253: * int method(){};
0254: * void foo() {method()} -> void foo() {this.method();}
0255: * </pre></code> <br>
0256: * Only has an effect if {@link #MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS}
0257: * is TRUE <br>
0258: * <br>
0259: * Possible values: {TRUE, FALSE}<br>
0260: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0261: * <br>
0262: *
0263: * @see #TRUE
0264: * @see #FALSE
0265: * @since 3.3
0266: */
0267: public static final String MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS_ALWAYS = "cleanup.always_use_this_for_non_static_method_access"; //$NON-NLS-1$
0268:
0269: /**
0270: * Removes 'this' qualifier to field accesses.
0271: * <p>
0272: * i.e.:
0273: *
0274: * <pre><code>
0275: * int fField;
0276: * void foo() {this.fField= 10;} -> void foo() {fField= 10;}
0277: * </pre></code> <br>
0278: * Only has an effect if {@link #MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS}
0279: * is TRUE <br>
0280: * <br>
0281: * Possible values: {TRUE, FALSE}<br>
0282: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0283: * <br>
0284: *
0285: * @see #TRUE
0286: * @see #FALSE
0287: * @since 3.3
0288: */
0289: public static final String MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS_IF_NECESSARY = "cleanup.use_this_for_non_static_method_access_only_if_necessary"; //$NON-NLS-1$
0290:
0291: /**
0292: * Controls access qualifiers for static members. For detailed settings use<br>
0293: * {@link #MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_FIELD}<br>
0294: * {@link #MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_INSTANCE_ACCESS}<br>
0295: * {@link #MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_METHOD}<br>
0296: * {@link #MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_SUBTYPE_ACCESS}
0297: * <br>
0298: * <br>
0299: * Possible values: {TRUE, FALSE}<br>
0300: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0301: * <br>
0302: *
0303: * @see #TRUE
0304: * @see #FALSE
0305: * @since 3.3
0306: */
0307: public static final String MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS = "cleanup.qualify_static_member_accesses_with_declaring_class"; //$NON-NLS-1$
0308:
0309: /**
0310: * Qualify static field accesses with declaring type.
0311: * <p>
0312: * i.e.:
0313: *
0314: * <pre><code>
0315: * class E {
0316: * public static int i;
0317: * void foo() {i= 10;} -> void foo() {E.i= 10;}
0318: * }
0319: * </code></pre>
0320: *
0321: * <br>
0322: * Only has an effect if
0323: * {@link #MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS} is TRUE <br>
0324: * <br>
0325: * Possible values: {TRUE, FALSE}<br>
0326: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0327: * <br>
0328: *
0329: * @see #TRUE
0330: * @see #FALSE
0331: * @since 3.3
0332: */
0333: public static final String MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_FIELD = "cleanup.qualify_static_field_accesses_with_declaring_class"; //$NON-NLS-1$
0334:
0335: /**
0336: * Qualifies static method accesses with declaring type.
0337: * <p>
0338: * i.e.:
0339: *
0340: * <pre><code>
0341: * class E {
0342: * public static int m();
0343: * void foo() {m();} -> void foo() {E.m();}
0344: * }
0345: * </code></pre>
0346: *
0347: * <br>
0348: * Only has an effect if
0349: * {@link #MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS} is TRUE <br>
0350: * <br>
0351: * Possible values: {TRUE, FALSE}<br>
0352: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0353: * <br>
0354: *
0355: * @see #TRUE
0356: * @see #FALSE
0357: * @since 3.3
0358: */
0359: public static final String MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_METHOD = "cleanup.qualify_static_method_accesses_with_declaring_class"; //$NON-NLS-1$
0360:
0361: /**
0362: * Changes indirect accesses to static members to direct ones.
0363: * <p>
0364: * i.e.:
0365: *
0366: * <pre><code>
0367: * class E {public static int i;}
0368: * class ESub extends E {
0369: * void foo() {ESub.i= 10;} -> void foo() {E.i= 10;}
0370: * }
0371: * </code></pre>
0372: *
0373: * <br>
0374: * Only has an effect if
0375: * {@link #MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS} is TRUE <br>
0376: * <br>
0377: * Possible values: {TRUE, FALSE}<br>
0378: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0379: * <br>
0380: *
0381: * @see #TRUE
0382: * @see #FALSE
0383: * @since 3.3
0384: */
0385: public static final String MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_SUBTYPE_ACCESS = "cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class"; //$NON-NLS-1$
0386:
0387: /**
0388: * Changes non static accesses to static members to static accesses.
0389: * <p>
0390: * i.e.:
0391: *
0392: * <pre><code>
0393: * class E {
0394: * public static int i;
0395: * void foo() {(new E()).i= 10;} -> void foo() {E.i= 10;}
0396: * }
0397: * </code></pre>
0398: *
0399: * <br>
0400: * Only has an effect if
0401: * {@link #MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS} is TRUE <br>
0402: * <br>
0403: * Possible values: {TRUE, FALSE}<br>
0404: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0405: * <br>
0406: *
0407: * @see #TRUE
0408: * @see #FALSE
0409: * @since 3.3
0410: */
0411: public static final String MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_INSTANCE_ACCESS = "cleanup.qualify_static_member_accesses_through_instances_with_declaring_class"; //$NON-NLS-1$
0412:
0413: /**
0414: * Controls the usage of blocks around single control statement bodies. For
0415: * detailed settings use<br>
0416: * {@link #CONTROL_STATMENTS_USE_BLOCKS_ALWAYS}<br>
0417: * {@link #CONTROL_STATMENTS_USE_BLOCKS_NEVER}<br>
0418: * {@link #CONTROL_STATMENTS_USE_BLOCKS_NO_FOR_RETURN_AND_THROW} <br>
0419: * <br>
0420: * Possible values: {TRUE, FALSE}<br>
0421: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0422: * <br>
0423: *
0424: * @see #TRUE
0425: * @see #FALSE
0426: * @since 3.3
0427: */
0428: public static final String CONTROL_STATEMENTS_USE_BLOCKS = "cleanup.use_blocks"; //$NON-NLS-1$
0429:
0430: /**
0431: * Adds block to control statement body if the body is not a block.
0432: * <p>
0433: * i.e.:
0434: *
0435: * <pre><code>
0436: * if (b) foo(); -> if (b) {foo();}
0437: * </code></pre>
0438: *
0439: * <br>
0440: * Only has an effect if {@link #CONTROL_STATEMENTS_USE_BLOCKS} is TRUE <br>
0441: * <br>
0442: * Possible values: {TRUE, FALSE}<br>
0443: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0444: * <br>
0445: *
0446: * @see #TRUE
0447: * @see #FALSE
0448: * @since 3.3
0449: */
0450: public static final String CONTROL_STATMENTS_USE_BLOCKS_ALWAYS = "cleanup.always_use_blocks"; //$NON-NLS-1$
0451:
0452: /**
0453: * Remove unnecessary blocks in control statement bodies if they contain a
0454: * single return or throw statement.
0455: * <p>
0456: * i.e.:
0457: *
0458: * <pre><code>
0459: * if (b) {return;} -> if (b) return;
0460: * </code></pre>
0461: *
0462: * <br>
0463: * Only has an effect if {@link #CONTROL_STATEMENTS_USE_BLOCKS} is TRUE <br>
0464: * <br>
0465: * Possible values: {TRUE, FALSE}<br>
0466: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0467: * <br>
0468: *
0469: * @see #TRUE
0470: * @see #FALSE
0471: * @since 3.3
0472: */
0473: public static final String CONTROL_STATMENTS_USE_BLOCKS_NO_FOR_RETURN_AND_THROW = "cleanup.use_blocks_only_for_return_and_throw"; //$NON-NLS-1$
0474:
0475: /**
0476: * Remove unnecessary blocks in control statement bodies.
0477: * <p>
0478: * i.e.:
0479: *
0480: * <pre><code>
0481: * if (b) {foo();} -> if (b) foo();
0482: * </code></pre>
0483: *
0484: * <br>
0485: * Only has an effect if {@link #CONTROL_STATEMENTS_USE_BLOCKS} is TRUE <br>
0486: * <br>
0487: * Possible values: {TRUE, FALSE}<br>
0488: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0489: * <br>
0490: *
0491: * @see #TRUE
0492: * @see #FALSE
0493: * @since 3.3
0494: */
0495: public static final String CONTROL_STATMENTS_USE_BLOCKS_NEVER = "cleanup.never_use_blocks"; //$NON-NLS-1$
0496:
0497: /**
0498: * Convert for loops to enhanced for loops.
0499: * <p>
0500: * i.e.:
0501: *
0502: * <pre><code>
0503: * for (int i = 0; i < array.length; i++) {} -> for (int element : array) {}
0504: * </code></pre>
0505: *
0506: * <br>
0507: * <br>
0508: * Possible values: {TRUE, FALSE}<br>
0509: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0510: * <br>
0511: *
0512: * @see #TRUE
0513: * @see #FALSE
0514: * @since 3.3
0515: */
0516: public static final String CONTROL_STATMENTS_CONVERT_FOR_LOOP_TO_ENHANCED = "cleanup.convert_to_enhanced_for_loop"; //$NON-NLS-1$
0517:
0518: /**
0519: * Controls the usage of parenthesis in expressions. For detailed settings
0520: * use<br>
0521: * {@link #EXPRESSIONS_USE_PARENTHESES_ALWAYS}<br>
0522: * {@link #EXPRESSIONS_USE_PARENTHESES_NEVER}<br>
0523: * <br>
0524: * <br>
0525: * Possible values: {TRUE, FALSE}<br>
0526: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0527: * <br>
0528: *
0529: * @see #TRUE
0530: * @see #FALSE
0531: * @since 3.3
0532: */
0533: public static final String EXPRESSIONS_USE_PARENTHESES = "cleanup.use_parentheses_in_expressions"; //$NON-NLS-1$
0534:
0535: /**
0536: * Add paranoic parenthesis around conditional expressions.
0537: * <p>
0538: * i.e.:
0539: *
0540: * <pre><code>
0541: * boolean b= i > 10 && i < 100 || i > 20;
0542: * ->
0543: * boolean b= ((i > 10) && (i < 100)) || (i > 20);
0544: * </pre></code> <br>
0545: * Only has an effect if {@link #EXPRESSIONS_USE_PARENTHESES} is TRUE <br>
0546: * <br>
0547: * Possible values: {TRUE, FALSE}<br>
0548: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0549: * <br>
0550: *
0551: * @see #TRUE
0552: * @see #FALSE
0553: * @since 3.3
0554: */
0555: public static final String EXPRESSIONS_USE_PARENTHESES_ALWAYS = "cleanup.always_use_parentheses_in_expressions"; //$NON-NLS-1$
0556:
0557: /**
0558: * Remove unnecessary parenthesis around conditional expressions.
0559: * <p>
0560: * i.e.:
0561: *
0562: * <pre><code>
0563: * boolean b= ((i > 10) && (i < 100)) || (i > 20);
0564: * ->
0565: * boolean b= i > 10 && i < 100 || i > 20;
0566: * </pre></code> <br>
0567: * Only has an effect if {@link #EXPRESSIONS_USE_PARENTHESES} is TRUE <br>
0568: * <br>
0569: * Possible values: {TRUE, FALSE}<br>
0570: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0571: * <br>
0572: *
0573: * @see #TRUE
0574: * @see #FALSE
0575: * @since 3.3
0576: */
0577: public static final String EXPRESSIONS_USE_PARENTHESES_NEVER = "cleanup.never_use_parentheses_in_expressions"; //$NON-NLS-1$
0578:
0579: /**
0580: * Controls the usage of 'final' modifier for variable declarations. For
0581: * detailed settings use:<br>
0582: * {@link #VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES}<br>
0583: * {@link #VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS}<br>
0584: * {@link #VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS} <br>
0585: * <br>
0586: * Possible values: {TRUE, FALSE}<br>
0587: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0588: * <br>
0589: *
0590: * @see #TRUE
0591: * @see #FALSE
0592: * @since 3.3
0593: */
0594: public static final String VARIABLE_DECLARATIONS_USE_FINAL = "cleanup.make_variable_declarations_final"; //$NON-NLS-1$
0595:
0596: /**
0597: * Add a final modifier to private fields where possible i.e.:
0598: *
0599: * <pre><code>
0600: * private int field= 0; -> private final int field= 0;
0601: * </code></pre>
0602: *
0603: * <br>
0604: * Only has an effect if {@link #VARIABLE_DECLARATIONS_USE_FINAL} is TRUE
0605: * <br>
0606: * <br>
0607: * Possible values: {TRUE, FALSE}<br>
0608: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0609: * <br>
0610: *
0611: * @see #TRUE
0612: * @see #FALSE
0613: * @since 3.3
0614: */
0615: public static final String VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS = "cleanup.make_private_fields_final"; //$NON-NLS-1$
0616:
0617: /**
0618: * Add a final modifier to method parameters where possible i.e.:
0619: *
0620: * <pre><code>
0621: * void foo(int i) {} -> void foo(final int i) {}
0622: * </code></pre>
0623: *
0624: * <br>
0625: * Only has an effect if {@link #VARIABLE_DECLARATIONS_USE_FINAL} is TRUE
0626: * <br>
0627: * <br>
0628: * Possible values: {TRUE, FALSE}<br>
0629: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0630: * <br>
0631: *
0632: * @see #TRUE
0633: * @see #FALSE
0634: * @since 3.3
0635: */
0636: public static final String VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS = "cleanup.make_parameters_final"; //$NON-NLS-1$
0637:
0638: /**
0639: * Add a final modifier to local variables where possible i.e.:
0640: *
0641: * <pre><code>
0642: * int i= 0; -> final int i= 0;
0643: * </code></pre>
0644: *
0645: * <br>
0646: * Only has an effect if {@link #VARIABLE_DECLARATIONS_USE_FINAL} is TRUE
0647: * <br>
0648: * <br>
0649: * Possible values: {TRUE, FALSE}<br>
0650: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0651: * <br>
0652: *
0653: * @see #TRUE
0654: * @see #FALSE
0655: * @since 3.3
0656: */
0657: public static final String VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES = "cleanup.make_local_variable_final"; //$NON-NLS-1$
0658:
0659: /**
0660: * Adds type parameters to raw type references.
0661: * <p>
0662: * i.e.:
0663: *
0664: * <pre><code>
0665: * List l; -> List<Object> l;
0666: * </code></pre>
0667: *
0668: * <br>
0669: * Possible values: {TRUE, FALSE}<br>
0670: * Default value: Not set<br>
0671: * <br>
0672: *
0673: * @see #TRUE
0674: * @see #FALSE
0675: * @since 3.3
0676: */
0677: public static final String VARIABLE_DECLARATION_USE_TYPE_ARGUMENTS_FOR_RAW_TYPE_REFERENCES = "cleanup.use_arguments_for_raw_type_references"; //$NON-NLS-1$
0678:
0679: /**
0680: * Removes unused imports. <br>
0681: * <br>
0682: * Possible values: {TRUE, FALSE}<br>
0683: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0684: * <br>
0685: *
0686: * @see #TRUE
0687: * @see #FALSE
0688: * @since 3.3
0689: */
0690: public static final String REMOVE_UNUSED_CODE_IMPORTS = "cleanup.remove_unused_imports"; //$NON-NLS-1$
0691:
0692: /**
0693: * Controls the removal of unused private members. For detailed settings
0694: * use:<br>
0695: * {@link #REMOVE_UNUSED_CODE_PRIVATE_CONSTRUCTORS}<br>
0696: * {@link #REMOVE_UNUSED_CODE_PRIVATE_FELDS}<br>
0697: * {@link #REMOVE_UNUSED_CODE_PRIVATE_METHODS}<br>
0698: * {@link #REMOVE_UNUSED_CODE_PRIVATE_TYPES} <br>
0699: * <br>
0700: * Possible values: {TRUE, FALSE}<br>
0701: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0702: * <br>
0703: *
0704: * @see #TRUE
0705: * @see #FALSE
0706: * @since 3.3
0707: */
0708: public static final String REMOVE_UNUSED_CODE_PRIVATE_MEMBERS = "cleanup.remove_unused_private_members"; //$NON-NLS-1$
0709:
0710: /**
0711: * Removes unused private types. <br>
0712: * Only has an effect if {@link #REMOVE_UNUSED_CODE_PRIVATE_MEMBERS} is TRUE
0713: * <br>
0714: * <br>
0715: * Possible values: {TRUE, FALSE}<br>
0716: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0717: * <br>
0718: *
0719: * @see #TRUE
0720: * @see #FALSE
0721: * @since 3.3
0722: */
0723: public static final String REMOVE_UNUSED_CODE_PRIVATE_TYPES = "cleanup.remove_unused_private_types"; //$NON-NLS-1$
0724:
0725: /**
0726: * Removes unused private constructors. <br>
0727: * Only has an effect if {@link #REMOVE_UNUSED_CODE_PRIVATE_MEMBERS} is TRUE
0728: * <br>
0729: * <br>
0730: * Possible values: {TRUE, FALSE}<br>
0731: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0732: * <br>
0733: *
0734: * @see #TRUE
0735: * @see #FALSE
0736: * @since 3.3
0737: */
0738: public static final String REMOVE_UNUSED_CODE_PRIVATE_CONSTRUCTORS = "cleanup.remove_private_constructors"; //$NON-NLS-1$
0739:
0740: /**
0741: * Removes unused private fields. <br>
0742: * Only has an effect if {@link #REMOVE_UNUSED_CODE_PRIVATE_MEMBERS} is TRUE
0743: * <br>
0744: * <br>
0745: * Possible values: {TRUE, FALSE}<br>
0746: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0747: * <br>
0748: *
0749: * @see #TRUE
0750: * @see #FALSE
0751: * @since 3.3
0752: */
0753: public static final String REMOVE_UNUSED_CODE_PRIVATE_FELDS = "cleanup.remove_unused_private_fields"; //$NON-NLS-1$
0754:
0755: /**
0756: * Removes unused private methods. <br>
0757: * Only has an effect if {@link #REMOVE_UNUSED_CODE_PRIVATE_MEMBERS} is TRUE
0758: * <br>
0759: * <br>
0760: * Possible values: {TRUE, FALSE}<br>
0761: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0762: * <br>
0763: *
0764: * @see #TRUE
0765: * @see #FALSE
0766: * @since 3.3
0767: */
0768: public static final String REMOVE_UNUSED_CODE_PRIVATE_METHODS = "cleanup.remove_unused_private_methods"; //$NON-NLS-1$
0769:
0770: /**
0771: * Removes unused local variables. <br>
0772: * <br>
0773: * Possible values: {TRUE, FALSE}<br>
0774: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0775: * <br>
0776: *
0777: * @see #TRUE
0778: * @see #FALSE
0779: * @since 3.3
0780: */
0781: public static final String REMOVE_UNUSED_CODE_LOCAL_VARIABLES = "cleanup.remove_unused_local_variables"; //$NON-NLS-1$
0782:
0783: /**
0784: * Removes unused casts. <br>
0785: * <br>
0786: * Possible values: {TRUE, FALSE}<br>
0787: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0788: * <br>
0789: *
0790: * @see #TRUE
0791: * @see #FALSE
0792: * @since 3.3
0793: */
0794: public static final String REMOVE_UNNECESSARY_CASTS = "cleanup.remove_unnecessary_casts"; //$NON-NLS-1$
0795:
0796: /**
0797: * Remove unnecessary '$NON-NLS$' tags.
0798: * <p>
0799: * i.e.:
0800: *
0801: * <pre><code>
0802: * String s; //$NON-NLS-1$ -> String s;
0803: * </code></pre>
0804: *
0805: * <br>
0806: * <br>
0807: * Possible values: {TRUE, FALSE}<br>
0808: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0809: * <br>
0810: *
0811: * @see #TRUE
0812: * @see #FALSE
0813: * @since 3.3
0814: */
0815: public static final String REMOVE_UNNECESSARY_NLS_TAGS = "cleanup.remove_unnecessary_nls_tags"; //$NON-NLS-1$
0816:
0817: /**
0818: * Controls whether missing annotations should be added to the code. For
0819: * detailed settings use:<br>
0820: * {@link #ADD_MISSING_ANNOTATIONS_DEPRECATED}<br>
0821: * {@value #ADD_MISSING_ANNOTATIONS_OVERRIDE} <br>
0822: * <br>
0823: * Possible values: {TRUE, FALSE}<br>
0824: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0825: * <br>
0826: *
0827: * @see #TRUE
0828: * @see #FALSE
0829: * @since 3.3
0830: */
0831: public static final String ADD_MISSING_ANNOTATIONS = "cleanup.add_missing_annotations"; //$NON-NLS-1$
0832:
0833: /**
0834: * Add '@Override' annotation in front of overriding methods.
0835: * <p>
0836: * i.e.:
0837: *
0838: * <pre><code>
0839: * class E1 {void foo();}
0840: * class E2 extends E1 {
0841: * void foo(); -> @Override void foo();
0842: * }
0843: * </pre></code> <br>
0844: * Only has an effect if {@link #ADD_MISSING_ANNOTATIONS} is TRUE
0845: * <br>
0846: * <br>
0847: * Possible values: {TRUE, FALSE}<br>
0848: * Default value: Value returned by
0849: * {@link #getEclipseDefaultSettings()}<br>
0850: * <br>
0851: *
0852: * @see #TRUE
0853: * @see #FALSE
0854: * @since 3.3
0855: */
0856: public static final String ADD_MISSING_ANNOTATIONS_OVERRIDE = "cleanup.add_missing_override_annotations"; //$NON-NLS-1$
0857:
0858: /**
0859: * Add '@Deprecated' annotation in front of deprecated members.
0860: * <p>
0861: * i.e.:
0862: *
0863: * <pre><code>
0864: * /**@deprecated* /
0865: * int i;
0866: * ->
0867: * /**@deprecated* /
0868: * @Deprecated
0869: * int i;
0870: * </pre></code> <br>
0871: * Only has an effect if {@link #ADD_MISSING_ANNOTATIONS} is TRUE <br>
0872: * <br>
0873: * Possible values: {TRUE, FALSE}<br>
0874: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0875: * <br>
0876: *
0877: * @see #TRUE
0878: * @see #FALSE
0879: * @since 3.3
0880: */
0881: public static final String ADD_MISSING_ANNOTATIONS_DEPRECATED = "cleanup.add_missing_deprecated_annotations"; //$NON-NLS-1$
0882:
0883: /**
0884: * Controls whether missing serial version ids should be added to the code.
0885: * For detailed settings use:<br>
0886: * {@link #ADD_MISSING_SERIAL_VERSION_ID_DEFAULT}<br>
0887: * {@link #ADD_MISSING_SERIAL_VERSION_ID_GENERATED} <br>
0888: * <br>
0889: * Possible values: {TRUE, FALSE}<br>
0890: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0891: * <br>
0892: *
0893: * @see #TRUE
0894: * @see #FALSE
0895: * @since 3.3
0896: */
0897: public static final String ADD_MISSING_SERIAL_VERSION_ID = "cleanup.add_serial_version_id"; //$NON-NLS-1$
0898:
0899: /**
0900: * Adds a generated serial version id to subtypes of java.io.Serializable
0901: * and java.io.Externalizable
0902: *
0903: * public class E implements Serializable {} -> public class E implements
0904: * Serializable { private static final long serialVersionUID = 4381024239L; }
0905: * <br>
0906: * Only has an effect if {@link #ADD_MISSING_SERIAL_VERSION_ID} is TRUE <br>
0907: * <br>
0908: * Possible values: {TRUE, FALSE}<br>
0909: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0910: * <br>
0911: *
0912: * @see #TRUE
0913: * @see #FALSE
0914: * @since 3.3
0915: */
0916: public static final String ADD_MISSING_SERIAL_VERSION_ID_GENERATED = "cleanup.add_generated_serial_version_id"; //$NON-NLS-1$
0917:
0918: /**
0919: * Adds a default serial version it to subtypes of java.io.Serializable and
0920: * java.io.Externalizable
0921: *
0922: * public class E implements Serializable {} -> public class E implements
0923: * Serializable { private static final long serialVersionUID = 1L; } <br>
0924: * Only has an effect if {@link #ADD_MISSING_SERIAL_VERSION_ID} is TRUE <br>
0925: * <br>
0926: * Possible values: {TRUE, FALSE}<br>
0927: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0928: * <br>
0929: *
0930: * @see #TRUE
0931: * @see #FALSE
0932: * @since 3.3
0933: */
0934: public static final String ADD_MISSING_SERIAL_VERSION_ID_DEFAULT = "cleanup.add_default_serial_version_id"; //$NON-NLS-1$
0935:
0936: /**
0937: * Add '$NON-NLS$' tags to non externalized strings.
0938: * <p>
0939: * i.e.:
0940: *
0941: * <pre><code>
0942: * String s= ""; -> String s= ""; //$NON-NLS-1$
0943: * </code></pre>
0944: *
0945: * <br>
0946: * <br>
0947: * Possible values: {TRUE, FALSE}<br>
0948: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0949: * <br>
0950: *
0951: * @see #TRUE
0952: * @see #FALSE
0953: * @since 3.3
0954: */
0955: public static final String ADD_MISSING_NLS_TAGS = "cleanup.add_missing_nls_tags"; //$NON-NLS-1$
0956:
0957: /**
0958: * If true the imports are organized while cleaning up code.
0959: *
0960: * Possible values: {TRUE, FALSE}<br>
0961: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0962: * <br>
0963: *
0964: * @see #TRUE
0965: * @see #FALSE
0966: * @since 3.3
0967: */
0968: public static final String ORGANIZE_IMPORTS = "cleanup.organize_imports"; //$NON-NLS-1$
0969:
0970: /**
0971: * Should members be sorted?
0972: * <br><br>
0973: * Possible values: {TRUE, FALSE}<br>
0974: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0975: * <br>
0976: *
0977: * @see #SORT_MEMBERS_ALL
0978: * @see #TRUE
0979: * @see #FALSE
0980: * @since 3.3
0981: */
0982: public static final String SORT_MEMBERS = "cleanup.sort_members"; //$NON-NLS-1$
0983:
0984: /**
0985: * If sorting members, should fields, enum constants and initializers also be sorted?
0986: * <br>
0987: * This has only an effect if {@link #SORT_MEMBERS} is also enabled.
0988: * <br>
0989: * <br>
0990: * Possible values: {TRUE, FALSE}<br>
0991: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
0992: * <br>
0993: *
0994: * @see #SORT_MEMBERS
0995: * @see #TRUE
0996: * @see #FALSE
0997: * @since 3.3
0998: */
0999: public static final String SORT_MEMBERS_ALL = "cleanup.sort_members_all"; //$NON-NLS-1$
1000:
1001: /**
1002: * If enabled method stubs are added to all non abstract classes which
1003: * require to implement some methods.
1004: * <br>
1005: * Possible values: {TRUE, FALSE}<br>
1006: * Default value: Value returned by {@link #getEclipseDefaultSettings()}<br>
1007: * <br>
1008: *
1009: * @see #TRUE
1010: * @see #FALSE
1011: * @since 3.4
1012: */
1013: public static final String ADD_MISSING_METHODES = "cleanup.add_missing_methods"; //$NON-NLS-1$
1014:
1015: /**
1016: * Should the Clean Up Wizard be shown when executing the Clean Up Action?
1017: * <br>
1018: * <br>
1019: * Possible values: {<code><b>true</b></code>,
1020: * <code><b>false</b></code>}<br>
1021: * Default value: <code><b>true</b></code><br>
1022: * <br>
1023: *
1024: * @since 3.3
1025: */
1026: public static final String SHOW_CLEAN_UP_WIZARD = "cleanup.showwizard"; //$NON-NLS-1$
1027:
1028: /**
1029: * A key to a serialized string in the <code>InstanceScope</code>
1030: * containing all the profiles.<br>
1031: * Following code snippet can load the profiles:
1032: *
1033: * <pre><code>
1034: * List profiles= new ProfileStore(CLEANUP_PROFILES, new CleanUpVersioner()).readProfiles(new InstanceScope());
1035: * </code></pre>
1036: *
1037: * @since 3.3
1038: */
1039: public static final String CLEANUP_PROFILES = "org.eclipse.jdt.ui.cleanupprofiles"; //$NON-NLS-1$
1040:
1041: /**
1042: * Stores the id of the clean up profile used when executing clean up.<br>
1043: * <br>
1044: * Possible values: String value<br>
1045: * Default value: {@link #DEFAULT_PROFILE} <br>
1046: *
1047: * @since 3.3
1048: */
1049: public final static String CLEANUP_PROFILE = "cleanup_profile"; //$NON-NLS-1$$
1050:
1051: /**
1052: * Stores the id of the clean up profile used when executing clean up on
1053: * save.<br>
1054: * <br>
1055: * Possible values: String value<br>
1056: * Default value: {@link #DEFAULT_SAVE_PARTICIPANT_PROFILE} <br>
1057: *
1058: * @since 3.3
1059: */
1060: public static final String CLEANUP_ON_SAVE_PROFILE = "cleanup.on_save_profile_id"; //$NON-NLS-1$
1061:
1062: /**
1063: * A key to the version of the profile stored in the preferences.<br>
1064: * <br>
1065: * Possible values: Integer value<br>
1066: * Default value: {@link CleanUpProfileVersioner#CURRENT_VERSION} <br>
1067: *
1068: * @since 3.3
1069: */
1070: public final static String CLEANUP_SETTINGS_VERSION_KEY = "cleanup_settings_version"; //$NON-NLS-1$
1071:
1072: /**
1073: * Id of the 'Eclipse [built-in]' profile.<br>
1074: * <br>
1075: *
1076: * @since 3.3
1077: */
1078: public final static String ECLIPSE_PROFILE = "org.eclipse.jdt.ui.default.eclipse_clean_up_profile"; //$NON-NLS-1$
1079:
1080: /**
1081: * Id of the 'Save Participant [built-in]' profile.<br>
1082: * <br>
1083: *
1084: * @since 3.3
1085: */
1086: public final static String SAVE_PARTICIPANT_PROFILE = "org.eclipse.jdt.ui.default.save_participant_clean_up_profile"; //$NON-NLS-1$
1087:
1088: public static final String CLEANUP_ON_SAVE_ADDITIONAL_OPTIONS = "cleanup.on_save_use_additional_actions"; //$NON-NLS-1$
1089:
1090: /**
1091: * The id of the profile used as a default profile when executing clean up.<br>
1092: * <br>
1093: * Possible values: String value<br>
1094: * Default value: {@link #ECLIPSE_PROFILE} <br>
1095: *
1096: * @since 3.3
1097: */
1098: public final static String DEFAULT_PROFILE = ECLIPSE_PROFILE;
1099:
1100: /**
1101: * The id of the profile used as a default profile when executing clean up
1102: * on save.<br>
1103: * <br>
1104: * Possible values: String value<br>
1105: * Default value: {@link #SAVE_PARTICIPANT_PROFILE} <br>
1106: *
1107: * @since 3.3
1108: */
1109: public final static String DEFAULT_SAVE_PARTICIPANT_PROFILE = SAVE_PARTICIPANT_PROFILE;
1110:
1111: public static Map getEclipseDefaultSettings() {
1112: final HashMap result = new HashMap();
1113:
1114: //Member Accesses
1115: result.put(MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS, FALSE);
1116: result.put(MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS_ALWAYS,
1117: FALSE);
1118: result.put(
1119: MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS_IF_NECESSARY,
1120: TRUE);
1121:
1122: result.put(MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS, FALSE);
1123: result.put(MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS_ALWAYS,
1124: FALSE);
1125: result
1126: .put(
1127: MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS_IF_NECESSARY,
1128: TRUE);
1129:
1130: result.put(MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS,
1131: TRUE);
1132: result
1133: .put(
1134: MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_FIELD,
1135: FALSE);
1136: result
1137: .put(
1138: MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_METHOD,
1139: FALSE);
1140: result
1141: .put(
1142: MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_SUBTYPE_ACCESS,
1143: TRUE);
1144: result
1145: .put(
1146: MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_INSTANCE_ACCESS,
1147: TRUE);
1148:
1149: //Control Statements
1150: result.put(CONTROL_STATEMENTS_USE_BLOCKS, FALSE);
1151: result.put(CONTROL_STATMENTS_USE_BLOCKS_ALWAYS, TRUE);
1152: result.put(
1153: CONTROL_STATMENTS_USE_BLOCKS_NO_FOR_RETURN_AND_THROW,
1154: FALSE);
1155: result.put(CONTROL_STATMENTS_USE_BLOCKS_NEVER, FALSE);
1156:
1157: result.put(CONTROL_STATMENTS_CONVERT_FOR_LOOP_TO_ENHANCED,
1158: FALSE);
1159:
1160: //Expressions
1161: result.put(EXPRESSIONS_USE_PARENTHESES, FALSE);
1162: result.put(EXPRESSIONS_USE_PARENTHESES_NEVER, TRUE);
1163: result.put(EXPRESSIONS_USE_PARENTHESES_ALWAYS, FALSE);
1164:
1165: //Variable Declarations
1166: result.put(VARIABLE_DECLARATIONS_USE_FINAL, FALSE);
1167: result.put(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES,
1168: TRUE);
1169: result.put(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, FALSE);
1170: result
1171: .put(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS,
1172: TRUE);
1173:
1174: //Unused Code
1175: result.put(REMOVE_UNUSED_CODE_IMPORTS, TRUE);
1176: result.put(REMOVE_UNUSED_CODE_PRIVATE_MEMBERS, FALSE);
1177: result.put(REMOVE_UNUSED_CODE_PRIVATE_CONSTRUCTORS, TRUE);
1178: result.put(REMOVE_UNUSED_CODE_PRIVATE_FELDS, TRUE);
1179: result.put(REMOVE_UNUSED_CODE_PRIVATE_METHODS, TRUE);
1180: result.put(REMOVE_UNUSED_CODE_PRIVATE_TYPES, TRUE);
1181: result.put(REMOVE_UNUSED_CODE_LOCAL_VARIABLES, FALSE);
1182:
1183: //Unnecessary Code
1184: result.put(REMOVE_UNNECESSARY_CASTS, TRUE);
1185: result.put(REMOVE_UNNECESSARY_NLS_TAGS, TRUE);
1186:
1187: //Missing Code
1188: result.put(ADD_MISSING_ANNOTATIONS, TRUE);
1189: result.put(ADD_MISSING_ANNOTATIONS_OVERRIDE, TRUE);
1190: result.put(ADD_MISSING_ANNOTATIONS_DEPRECATED, TRUE);
1191:
1192: result.put(ADD_MISSING_SERIAL_VERSION_ID, FALSE);
1193: result.put(ADD_MISSING_SERIAL_VERSION_ID_GENERATED, FALSE);
1194: result.put(ADD_MISSING_SERIAL_VERSION_ID_DEFAULT, TRUE);
1195:
1196: result.put(ADD_MISSING_NLS_TAGS, FALSE);
1197:
1198: result.put(ADD_MISSING_METHODES, FALSE);
1199:
1200: //Code Organizing
1201: result.put(FORMAT_SOURCE_CODE, FALSE);
1202:
1203: result.put(FORMAT_REMOVE_TRAILING_WHITESPACES, FALSE);
1204: result.put(FORMAT_REMOVE_TRAILING_WHITESPACES_ALL, TRUE);
1205: result.put(FORMAT_REMOVE_TRAILING_WHITESPACES_IGNORE_EMPTY,
1206: FALSE);
1207:
1208: result.put(FORMAT_CORRECT_INDENTATION, FALSE);
1209:
1210: result.put(ORGANIZE_IMPORTS, FALSE);
1211:
1212: result.put(SORT_MEMBERS, FALSE);
1213: result.put(SORT_MEMBERS_ALL, FALSE);
1214:
1215: return result;
1216: }
1217:
1218: public static Map getSaveParticipantSettings() {
1219: final HashMap result = new HashMap();
1220:
1221: //Member Accesses
1222: result.put(MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS, FALSE);
1223: result.put(MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS_ALWAYS,
1224: FALSE);
1225: result.put(
1226: MEMBER_ACCESSES_NON_STATIC_FIELD_USE_THIS_IF_NECESSARY,
1227: TRUE);
1228:
1229: result.put(MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS, FALSE);
1230: result.put(MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS_ALWAYS,
1231: FALSE);
1232: result
1233: .put(
1234: MEMBER_ACCESSES_NON_STATIC_METHOD_USE_THIS_IF_NECESSARY,
1235: TRUE);
1236:
1237: result.put(MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS,
1238: FALSE);
1239: result
1240: .put(
1241: MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_FIELD,
1242: FALSE);
1243: result
1244: .put(
1245: MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_METHOD,
1246: FALSE);
1247: result
1248: .put(
1249: MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_SUBTYPE_ACCESS,
1250: TRUE);
1251: result
1252: .put(
1253: MEMBER_ACCESSES_STATIC_QUALIFY_WITH_DECLARING_CLASS_INSTANCE_ACCESS,
1254: TRUE);
1255:
1256: //Control Statements
1257: result.put(CONTROL_STATEMENTS_USE_BLOCKS, FALSE);
1258: result.put(CONTROL_STATMENTS_USE_BLOCKS_ALWAYS, TRUE);
1259: result.put(
1260: CONTROL_STATMENTS_USE_BLOCKS_NO_FOR_RETURN_AND_THROW,
1261: FALSE);
1262: result.put(CONTROL_STATMENTS_USE_BLOCKS_NEVER, FALSE);
1263:
1264: result.put(CONTROL_STATMENTS_CONVERT_FOR_LOOP_TO_ENHANCED,
1265: FALSE);
1266:
1267: //Expressions
1268: result.put(EXPRESSIONS_USE_PARENTHESES, FALSE);
1269: result.put(EXPRESSIONS_USE_PARENTHESES_NEVER, TRUE);
1270: result.put(EXPRESSIONS_USE_PARENTHESES_ALWAYS, FALSE);
1271:
1272: //Variable Declarations
1273: result.put(VARIABLE_DECLARATIONS_USE_FINAL, TRUE);
1274: result.put(VARIABLE_DECLARATIONS_USE_FINAL_LOCAL_VARIABLES,
1275: FALSE);
1276: result.put(VARIABLE_DECLARATIONS_USE_FINAL_PARAMETERS, FALSE);
1277: result
1278: .put(VARIABLE_DECLARATIONS_USE_FINAL_PRIVATE_FIELDS,
1279: TRUE);
1280:
1281: //Unused Code
1282: result.put(REMOVE_UNUSED_CODE_IMPORTS, FALSE);
1283: result.put(REMOVE_UNUSED_CODE_PRIVATE_MEMBERS, FALSE);
1284: result.put(REMOVE_UNUSED_CODE_PRIVATE_CONSTRUCTORS, TRUE);
1285: result.put(REMOVE_UNUSED_CODE_PRIVATE_FELDS, TRUE);
1286: result.put(REMOVE_UNUSED_CODE_PRIVATE_METHODS, TRUE);
1287: result.put(REMOVE_UNUSED_CODE_PRIVATE_TYPES, TRUE);
1288: result.put(REMOVE_UNUSED_CODE_LOCAL_VARIABLES, FALSE);
1289:
1290: //Unnecessary Code
1291: result.put(REMOVE_UNNECESSARY_CASTS, TRUE);
1292: result.put(REMOVE_UNNECESSARY_NLS_TAGS, FALSE);
1293:
1294: //Missing Code
1295: result.put(ADD_MISSING_ANNOTATIONS, TRUE);
1296: result.put(ADD_MISSING_ANNOTATIONS_OVERRIDE, TRUE);
1297: result.put(ADD_MISSING_ANNOTATIONS_DEPRECATED, TRUE);
1298:
1299: result.put(ADD_MISSING_SERIAL_VERSION_ID, FALSE);
1300: result.put(ADD_MISSING_SERIAL_VERSION_ID_GENERATED, FALSE);
1301: result.put(ADD_MISSING_SERIAL_VERSION_ID_DEFAULT, TRUE);
1302:
1303: result.put(ADD_MISSING_NLS_TAGS, FALSE);
1304:
1305: result.put(ADD_MISSING_METHODES, FALSE);
1306:
1307: //Code Organizing
1308: result.put(FORMAT_SOURCE_CODE, FALSE);
1309:
1310: result.put(FORMAT_REMOVE_TRAILING_WHITESPACES, FALSE);
1311: result.put(FORMAT_REMOVE_TRAILING_WHITESPACES_ALL, TRUE);
1312: result.put(FORMAT_REMOVE_TRAILING_WHITESPACES_IGNORE_EMPTY,
1313: FALSE);
1314:
1315: result.put(FORMAT_CORRECT_INDENTATION, FALSE);
1316:
1317: result.put(ORGANIZE_IMPORTS, TRUE);
1318:
1319: result.put(SORT_MEMBERS, FALSE);
1320: result.put(SORT_MEMBERS_ALL, FALSE);
1321:
1322: result.put(CLEANUP_ON_SAVE_ADDITIONAL_OPTIONS, FALSE);
1323:
1324: return result;
1325: }
1326:
1327: public static void initDefaults(IPreferenceStore store) {
1328: final Map settings = getEclipseDefaultSettings();
1329: for (final Iterator iterator = settings.keySet().iterator(); iterator
1330: .hasNext();) {
1331: final String key = (String) iterator.next();
1332: store.setDefault(key, (String) settings.get(key));
1333: }
1334:
1335: store.setDefault(SHOW_CLEAN_UP_WIZARD, true);
1336: store.setDefault(CLEANUP_PROFILE, DEFAULT_PROFILE);
1337: store.setDefault(CLEANUP_ON_SAVE_PROFILE,
1338: DEFAULT_SAVE_PARTICIPANT_PROFILE);
1339: }
1340:
1341: }
|