Java API By Example, From Geeks To Geeks.

1 /******************************************************************************* 2  * Copyright (c) 2000, 2007 IBM Corporation and others. 3  * All rights reserved. This program and the accompanying materials 4  * are made available under the terms of the Eclipse Public License v1.0 5  * which accompanies this distribution, and is available at 6  * http://www.eclipse.org/legal/epl-v10.html 7  * 8  * Contributors: 9  * IBM Corporation - initial API and implementation 10  *******************************************************************************/ 11 package org.eclipse.jdt.core.formatter; 12 13 import java.util.Map ; 14 15 import org.eclipse.jdt.core.JavaCore; 16 import org.eclipse.jdt.core.ToolFactory; 17 import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions; 18 import org.eclipse.jdt.internal.formatter.align.Alignment; 19 20 /** 21  * Constants used to set up the options of the code formatter. 22  * <p> 23  * This class is not intended to be instantiated or subclassed by clients. 24  * </p> 25  * 26  * @since 3.0 27  */ 28 public class DefaultCodeFormatterConstants { 29 30     /** 31      * <pre> 32      * FORMATTER / Value to set a brace location at the end of a line. 33      * </pre> 34      * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION 35      * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER 36      * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK 37      * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION 38      * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION 39      * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH 40      * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION 41      * @since 3.0 42      */ 43     public static final String END_OF_LINE = "end_of_line"; //$NON-NLS-1$ 44 45     /** 46      * <pre> 47      * FORMATTER / Value to set an option to false. 48      * </pre> 49      * @since 3.0 50      */ 51     public static final String FALSE = "false"; //$NON-NLS-1$ 52 53     /** 54      * <pre> 55      * FORMATTER / Option to align type members of a type declaration on column 56      * - option id: "org.eclipse.jdt.core.formatter.formatter.align_type_members_on_columns" 57      * - possible values: { TRUE, FALSE } 58      * - default: FALSE 59      * </pre> 60      * @see #TRUE 61      * @see #FALSE 62      * @since 3.0 63      */ 64     public static final String FORMATTER_ALIGN_TYPE_MEMBERS_ON_COLUMNS = JavaCore.PLUGIN_ID + ".formatter.align_type_members_on_columns"; //$NON-NLS-1$ 65 66     /** 67      * <pre> 68      * FORMATTER / Option for alignment of arguments in allocation expression 69      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" 70      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 71      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 72      * </pre> 73      * @see #createAlignmentValue(boolean, int, int) 74      * @since 3.0 75      */ 76     public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ALLOCATION_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_arguments_in_allocation_expression"; //$NON-NLS-1$ 77 /** 78      * <pre> 79      * FORMATTER / Option for alignment of arguments in enum constant 80      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant" 81      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 82      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 83      * </pre> 84      * @see #createAlignmentValue(boolean, int, int) 85      * @since 3.1 86      */ 87     public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.alignment_for_arguments_in_enum_constant"; //$NON-NLS-1$ 88 /** 89      * <pre> 90      * FORMATTER / Option for alignment of arguments in explicit constructor call 91      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call" 92      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 93      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 94      * </pre> 95      * @see #createAlignmentValue(boolean, int, int) 96      * @since 3.0 97      */ 98     public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_EXPLICIT_CONSTRUCTOR_CALL = JavaCore.PLUGIN_ID + ".formatter.alignment_for_arguments_in_explicit_constructor_call"; //$NON-NLS-1$ 99 /** 100      * <pre> 101      * FORMATTER / Option for alignment of arguments in method invocation 102      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation" 103      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 104      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 105      * </pre> 106      * @see #createAlignmentValue(boolean, int, int) 107      * @since 3.0 108      */ 109     public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_arguments_in_method_invocation"; //$NON-NLS-1$ 110 /** 111      * <pre> 112      * FORMATTER / Option for alignment of arguments in qualified allocation expression 113      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression" 114      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 115      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 116      * </pre> 117      * @see #createAlignmentValue(boolean, int, int) 118      * @since 3.0 119      */ 120     public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_QUALIFIED_ALLOCATION_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_arguments_in_qualified_allocation_expression"; //$NON-NLS-1$ 121 /** 122      * <pre> 123      * FORMATTER / Option for alignment of assignment 124      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_assignment" 125      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 126      * - default: createAlignmentValue(false, M_NO_ALIGNMENT, INDENT_DEFAULT) 127      * </pre> 128      * @see #createAlignmentValue(boolean, int, int) 129      * @since 3.2 130      */ 131     public static final String FORMATTER_ALIGNMENT_FOR_ASSIGNMENT = JavaCore.PLUGIN_ID + ".formatter.alignment_for_assignment"; //$NON-NLS-1$ 132 /** 133      * <pre> 134      * FORMATTER / Option for alignment of binary expression 135      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_binary_expression" 136      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 137      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 138      * </pre> 139      * @see #createAlignmentValue(boolean, int, int) 140      * @since 3.0 141      */ 142     public static final String FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_binary_expression"; //$NON-NLS-1$ 143 /** 144      * <pre> 145      * FORMATTER / Option for alignment of compact if 146      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_compact_if" 147      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 148      * - default: createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_BY_ONE) 149      * </pre> 150      * @see #createAlignmentValue(boolean, int, int) 151      * @since 3.0 152      */ 153     public static final String FORMATTER_ALIGNMENT_FOR_COMPACT_IF = JavaCore.PLUGIN_ID + ".formatter.alignment_for_compact_if"; //$NON-NLS-1$ 154 /** 155      * <pre> 156      * FORMATTER / Option for alignment of conditional expression 157      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" 158      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 159      * - default: createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_DEFAULT) 160      * </pre> 161      * @see #createAlignmentValue(boolean, int, int) 162      * @since 3.0 163      */ 164     public static final String FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_conditional_expression"; //$NON-NLS-1$ 165 /** 166      * <pre> 167      * FORMATTER / Option for alignment of enum constants 168      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_enum_constants" 169      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 170      * - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT) 171      * </pre> 172      * @see #createAlignmentValue(boolean, int, int) 173      * @since 3.1 174      */ 175     public static final String FORMATTER_ALIGNMENT_FOR_ENUM_CONSTANTS = JavaCore.PLUGIN_ID + ".formatter.alignment_for_enum_constants"; //$NON-NLS-1$ 176 /** 177      * <pre> 178      * FORMATTER / Option for alignment of expressions in array initializer 179      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer" 180      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 181      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 182      * </pre> 183      * @see #createAlignmentValue(boolean, int, int) 184      * @since 3.0 185      */ 186     public static final String FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.alignment_for_expressions_in_array_initializer"; //$NON-NLS-1$ 187 /** 188      * <pre> 189      * FORMATTER / Option for alignment of multiple fields 190      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_multiple_fields" 191      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 192      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 193      * </pre> 194      * @see #createAlignmentValue(boolean, int, int) 195      * @since 3.0 196      */ 197     public static final String FORMATTER_ALIGNMENT_FOR_MULTIPLE_FIELDS = JavaCore.PLUGIN_ID + ".formatter.alignment_for_multiple_fields";//$NON-NLS-1$ 198 /** 199      * <pre> 200      * FORMATTER / Option for alignment of parameters in constructor declaration 201      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" 202      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 203      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 204      * </pre> 205      * @see #createAlignmentValue(boolean, int, int) 206      * @since 3.0 207      */ 208     public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_CONSTRUCTOR_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_parameters_in_constructor_declaration"; //$NON-NLS-1$ 209 /** 210      * <pre> 211      * FORMATTER / Option for alignment of parameters in method declaration 212      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" 213      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 214      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 215      * </pre> 216      * @see #createAlignmentValue(boolean, int, int) 217      * @since 3.0 218      */ 219     public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_parameters_in_method_declaration"; //$NON-NLS-1$ 220 /** 221      * <pre> 222      * FORMATTER / Option for alignment of selector in method invocation 223      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation" 224      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 225      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 226      * </pre> 227      * @see #createAlignmentValue(boolean, int, int) 228      * @since 3.0 229      */ 230     public static final String FORMATTER_ALIGNMENT_FOR_SELECTOR_IN_METHOD_INVOCATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_selector_in_method_invocation"; //$NON-NLS-1$ 231 /** 232      * <pre> 233      * FORMATTER / Option for alignment of superclass in type declaration 234      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration" 235      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 236      * - default: createAlignmentValue(false, WRAP_NEXT_SHIFTED, INDENT_DEFAULT) 237      * </pre> 238      * @see #createAlignmentValue(boolean, int, int) 239      * @since 3.0 240      */ 241     public static final String FORMATTER_ALIGNMENT_FOR_SUPERCLASS_IN_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_superclass_in_type_declaration"; //$NON-NLS-1$ 242 /** 243      * <pre> 244      * FORMATTER / Option for alignment of superinterfaces in enum declaration 245      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration" 246      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 247      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 248      * </pre> 249      * @see #createAlignmentValue(boolean, int, int) 250      * @since 3.1 251      */ 252     public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_ENUM_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_enum_declaration"; //$NON-NLS-1$ 253 /** 254      * <pre> 255      * FORMATTER / Option for alignment of superinterfaces in type declaration 256      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration" 257      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 258      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 259      * </pre> 260      * @see #createAlignmentValue(boolean, int, int) 261      * @since 3.0 262      */ 263     public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_type_declaration"; //$NON-NLS-1$ 264 /** 265      * <pre> 266      * FORMATTER / Option for alignment of throws clause in constructor declaration 267      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" 268      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 269      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 270      * </pre> 271      * @see #createAlignmentValue(boolean, int, int) 272      * @since 3.0 273      */ 274     public static final String FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_CONSTRUCTOR_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_throws_clause_in_constructor_declaration"; //$NON-NLS-1$ 275 /** 276      * <pre> 277      * FORMATTER / Option for alignment of throws clause in method declaration 278      * - option id: "org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" 279      * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 280      * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 281      * </pre> 282      * @see #createAlignmentValue(boolean, int, int) 283      * @since 3.0 284      */ 285     public static final String FORMATTER_ALIGNMENT_FOR_THROWS_CLAUSE_IN_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_throws_clause_in_method_declaration"; //$NON-NLS-1$ 286 287     /** 288      * <pre> 289      * FORMATTER / Option to add blank lines after the imports declaration 290      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_after_imports" 291      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 292      * - default: "0" 293      * </pre> 294      * @since 3.0 295      */ 296     public static final String FORMATTER_BLANK_LINES_AFTER_IMPORTS = JavaCore.PLUGIN_ID + ".formatter.blank_lines_after_imports"; //$NON-NLS-1$ 297 /** 298      * <pre> 299      * FORMATTER / Option to add blank lines after the package declaration 300      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_after_package" 301      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 302      * - default: "0" 303      * </pre> 304      * @since 3.0 305      */ 306     public static final String FORMATTER_BLANK_LINES_AFTER_PACKAGE = JavaCore.PLUGIN_ID + ".formatter.blank_lines_after_package"; //$NON-NLS-1$ 307 /** 308      * <pre> 309      * FORMATTER / Option to add blank lines at the beginning of the method body 310      * - option id: "org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body" 311      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 312      * - default: "0" 313      * </pre> 314      * @since 3.0 315      */ 316     public static final String FORMATTER_BLANK_LINES_AT_BEGINNING_OF_METHOD_BODY = JavaCore.PLUGIN_ID + ".formatter.number_of_blank_lines_at_beginning_of_method_body"; //$NON-NLS-1$ 317 /** 318      * <pre> 319      * FORMATTER / Option to add blank lines before a field declaration 320      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_field" 321      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 322      * - default: "0" 323      * </pre> 324      * @since 3.0 325      */ 326     public static final String FORMATTER_BLANK_LINES_BEFORE_FIELD = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_field"; //$NON-NLS-1$ 327 /** 328      * <pre> 329      * FORMATTER / Option to add blank lines before the first class body declaration 330      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration" 331      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 332      * - default: "0" 333      * </pre> 334      * @since 3.0 335      */ 336     public static final String FORMATTER_BLANK_LINES_BEFORE_FIRST_CLASS_BODY_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_first_class_body_declaration"; //$NON-NLS-1$ 337 /** 338      * <pre> 339      * FORMATTER / Option to add blank lines before the imports declaration 340      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_imports" 341      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 342      * - default: "0" 343      * </pre> 344      * @since 3.0 345      */ 346     public static final String FORMATTER_BLANK_LINES_BEFORE_IMPORTS = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_imports"; //$NON-NLS-1$ 347 /** 348      * <pre> 349      * FORMATTER / Option to add blank lines before a member type declaration 350      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_member_type" 351      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 352      * - default: "0" 353      * </pre> 354      * @since 3.0 355      */ 356     public static final String FORMATTER_BLANK_LINES_BEFORE_MEMBER_TYPE = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_member_type"; //$NON-NLS-1$ 357 /** 358      * <pre> 359      * FORMATTER / Option to add blank lines before a method declaration 360      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_method" 361      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 362      * - default: "0" 363      * </pre> 364      * @since 3.0 365      */ 366     public static final String FORMATTER_BLANK_LINES_BEFORE_METHOD = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_method"; //$NON-NLS-1$ 367 /** 368      * <pre> 369      * FORMATTER / Option to add blank lines before a new chunk 370      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk" 371      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 372      * - default: "0" 373      * </pre> 374      * @since 3.0 375      */ 376     public static final String FORMATTER_BLANK_LINES_BEFORE_NEW_CHUNK = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_new_chunk"; //$NON-NLS-1$ 377 /** 378      * <pre> 379      * FORMATTER / Option to add blank lines before the package declaration 380      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_package" 381      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 382      * - default: "0" 383      * </pre> 384      * @since 3.0 385      */ 386     public static final String FORMATTER_BLANK_LINES_BEFORE_PACKAGE = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_package"; //$NON-NLS-1$ 387 /** 388      * <pre> 389      * FORMATTER / Option to add blank lines between import groups 390      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_between_import_groups" 391      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 392      * - default: "1" 393      * </pre> 394      * Note: Import groups are defined once "Organize Import" operation has been executed. The code formatter itself 395      * doesn't define the import groups. 396      * 397      * @since 3.3 398      */ 399     public static final String FORMATTER_BLANK_LINES_BETWEEN_IMPORT_GROUPS = JavaCore.PLUGIN_ID + ".formatter.blank_lines_between_import_groups"; //$NON-NLS-1$ 400 /** 401      * <pre> 402      * FORMATTER / Option to add blank lines between type declarations 403      * - option id: "org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" 404      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 405      * - default: "0" 406      * </pre> 407      * @since 3.0 408      */ 409     public static final String FORMATTER_BLANK_LINES_BETWEEN_TYPE_DECLARATIONS = JavaCore.PLUGIN_ID + ".formatter.blank_lines_between_type_declarations"; //$NON-NLS-1$ 410 /** 411      * <pre> 412      * FORMATTER / Option to position the braces of an annotation type declaration 413      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration" 414      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 415      * - default: END_OF_LINE 416      * </pre> 417      * @see #END_OF_LINE 418      * @see #NEXT_LINE 419      * @see #NEXT_LINE_SHIFTED 420      * @see #NEXT_LINE_ON_WRAP 421      * @since 3.1 422      */ 423     public static final String FORMATTER_BRACE_POSITION_FOR_ANNOTATION_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_annotation_type_declaration"; //$NON-NLS-1$ 424 /** 425      * <pre> 426      * FORMATTER / Option to position the braces of an anonymous type declaration 427      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration" 428      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 429      * - default: END_OF_LINE 430      * </pre> 431      * @see #END_OF_LINE 432      * @see #NEXT_LINE 433      * @see #NEXT_LINE_SHIFTED 434      * @see #NEXT_LINE_ON_WRAP 435      * @since 3.0 436      */ 437     public static final String FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_anonymous_type_declaration"; //$NON-NLS-1$ 438 /** 439      * <pre> 440      * FORMATTER / Option to position the braces of an array initializer 441      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_array_initializer" 442      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 443      * - default: END_OF_LINE 444      * </pre> 445      * @see #END_OF_LINE 446      * @see #NEXT_LINE 447      * @see #NEXT_LINE_SHIFTED 448      * @see #NEXT_LINE_ON_WRAP 449      * @since 3.0 450      */ 451     public static final String FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_array_initializer"; //$NON-NLS-1$ 452 /** 453      * <pre> 454      * FORMATTER / Option to position the braces of a block 455      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_block" 456      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 457      * - default: END_OF_LINE 458      * </pre> 459      * @see #END_OF_LINE 460      * @see #NEXT_LINE 461      * @see #NEXT_LINE_SHIFTED 462      * @see #NEXT_LINE_ON_WRAP 463      * @since 3.0 464      */ 465     public static final String FORMATTER_BRACE_POSITION_FOR_BLOCK = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_block"; //$NON-NLS-1$ 466 /** 467      * <pre> 468      * FORMATTER / Option to position the braces of a block in a case statement when the block is the first statement following 469      * the case 470      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_block_in_case" 471      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 472      * - default: END_OF_LINE 473      * </pre> 474      * @see #END_OF_LINE 475      * @see #NEXT_LINE 476      * @see #NEXT_LINE_SHIFTED 477      * @see #NEXT_LINE_ON_WRAP 478      * @since 3.0 479      */ 480     public static final String FORMATTER_BRACE_POSITION_FOR_BLOCK_IN_CASE = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_block_in_case"; //$NON-NLS-1$ 481 /** 482      * <pre> 483      * FORMATTER / Option to position the braces of a constructor declaration 484      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration" 485      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 486      * - default: END_OF_LINE 487      * </pre> 488      * @see #END_OF_LINE 489      * @see #NEXT_LINE 490      * @see #NEXT_LINE_SHIFTED 491      * @see #NEXT_LINE_ON_WRAP 492      * @since 3.0 493      */ 494     public static final String FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_constructor_declaration"; //$NON-NLS-1$ 495 /** 496      * <pre> 497      * FORMATTER / Option to position the braces of an enum constant 498      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_enum_constant" 499      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 500      * - default: END_OF_LINE 501      * </pre> 502      * @see #END_OF_LINE 503      * @see #NEXT_LINE 504      * @see #NEXT_LINE_SHIFTED 505      * @see #NEXT_LINE_ON_WRAP 506      * @since 3.1 507      */ 508     public static final String FORMATTER_BRACE_POSITION_FOR_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_enum_constant"; //$NON-NLS-1$ 509 /** 510      * <pre> 511      * FORMATTER / Option to position the braces of an enum declaration 512      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration" 513      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 514      * - default: END_OF_LINE 515      * </pre> 516      * @see #END_OF_LINE 517      * @see #NEXT_LINE 518      * @see #NEXT_LINE_SHIFTED 519      * @see #NEXT_LINE_ON_WRAP 520      * @since 3.1 521      */ 522     public static final String FORMATTER_BRACE_POSITION_FOR_ENUM_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_enum_declaration"; //$NON-NLS-1$ 523 /** 524      * <pre> 525      * FORMATTER / Option to position the braces of a method declaration 526      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_method_declaration" 527      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 528      * - default: END_OF_LINE 529      * </pre> 530      * @see #END_OF_LINE 531      * @see #NEXT_LINE 532      * @see #NEXT_LINE_SHIFTED 533      * @see #NEXT_LINE_ON_WRAP 534      * @since 3.0 535      */ 536     public static final String FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_method_declaration"; //$NON-NLS-1$ 537 /** 538      * <pre> 539      * FORMATTER / Option to position the braces of a switch statement 540      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_switch" 541      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 542      * - default: END_OF_LINE 543      * </pre> 544      * @see #END_OF_LINE 545      * @see #NEXT_LINE 546      * @see #NEXT_LINE_SHIFTED 547      * @see #NEXT_LINE_ON_WRAP 548      * @since 3.0 549      */ 550     public static final String FORMATTER_BRACE_POSITION_FOR_SWITCH = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_switch"; //$NON-NLS-1$ 551 /** 552      * <pre> 553      * FORMATTER / Option to position the braces of a type declaration 554      * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_type_declaration" 555      * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 556      * - default: END_OF_LINE 557      * </pre> 558      * @see #END_OF_LINE 559      * @see #NEXT_LINE 560      * @see #NEXT_LINE_SHIFTED 561      * @see #NEXT_LINE_ON_WRAP 562      * @since 3.0 563      */ 564     public static final String FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_type_declaration"; //$NON-NLS-1$ 565 566     /** 567      * <pre> 568      * FORMATTER / Option to control whether blank lines are cleared inside comments 569      * - option id: "org.eclipse.jdt.core.formatter.comment.clear_blank_lines" 570      * - possible values: { TRUE, FALSE } 571      * - default: FALSE 572      * </pre> 573      * @see #TRUE 574      * @see #FALSE 575      * @since 3.1 576      * @deprecated Use {@link #FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_BLOCK_COMMENT} and {@link #FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_JAVADOC_COMMENT} 577      */ 578     public final static String FORMATTER_COMMENT_CLEAR_BLANK_LINES = "org.eclipse.jdt.core.formatter.comment.clear_blank_lines"; //$NON-NLS-1$ 579 580     /** 581      * <pre> 582      * FORMATTER / Option to control whether blank lines are cleared inside javadoc comments 583      * - option id: "org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment" 584      * - possible values: { TRUE, FALSE } 585      * - default: FALSE 586      * </pre> 587      * @see #TRUE 588      * @see #FALSE 589      * @since 3.3 590      */ 591     public final static String FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_JAVADOC_COMMENT = "org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment"; //$NON-NLS-1$ 592 593     /** 594      * <pre> 595      * FORMATTER / Option to control whether blank lines are cleared inside block comments 596      * - option id: "org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment" 597      * - possible values: { TRUE, FALSE } 598      * - default: FALSE 599      * </pre> 600      * @see #TRUE 601      * @see #FALSE 602      * @since 3.3 603      */ 604     public final static String FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_BLOCK_COMMENT = "org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment"; //$NON-NLS-1$ 605 606     /** 607      * <pre> 608      * FORMATTER / Option to control whether comments are formatted 609      * - option id: "org.eclipse.jdt.core.formatter.comment.format_comments" 610      * - possible values: { TRUE, FALSE } 611      * - default: TRUE 612      * </pre> 613      * @see #TRUE 614      * @see #FALSE 615      * @since 3.1 616      * @deprecated Use multiple settings for each kind of comments. See {@link #FORMATTER_COMMENT_FORMAT_BLOCK_COMMENT}, 617      * {@link #FORMATTER_COMMENT_FORMAT_JAVADOC_COMMENT} and {@link #FORMATTER_COMMENT_FORMAT_LINE_COMMENT}. 618      */ 619     public final static String FORMATTER_COMMENT_FORMAT = "org.eclipse.jdt.core.formatter.comment.format_comments"; //$NON-NLS-1$ 620 621     /** 622      * <pre> 623      * FORMATTER / Option to control whether single line comments are formatted 624      * - option id: "org.eclipse.jdt.core.formatter.comment.format_line_comments" 625      * - possible values: { TRUE, FALSE } 626      * - default: TRUE 627      * </pre> 628      * @see #TRUE 629      * @see #FALSE 630      * @since 3.3 631      */ 632     public final static String FORMATTER_COMMENT_FORMAT_LINE_COMMENT = "org.eclipse.jdt.core.formatter.comment.format_line_comments"; //$NON-NLS-1$ 633 634     /** 635      * <pre> 636      * FORMATTER / Option to control whether multiple lines comments are formatted 637      * - option id: "org.eclipse.jdt.core.formatter.comment.format_block_comments" 638      * - possible values: { TRUE, FALSE } 639      * - default: TRUE 640      * </pre> 641      * @see #TRUE 642      * @see #FALSE 643      * @since 3.3 644      */ 645     public final static String FORMATTER_COMMENT_FORMAT_BLOCK_COMMENT = "org.eclipse.jdt.core.formatter.comment.format_block_comments"; //$NON-NLS-1$ 646 647     /** 648      * <pre> 649      * FORMATTER / Option to control whether javadoc comments are formatted 650      * - option id: "org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" 651      * - possible values: { TRUE, FALSE } 652      * - default: TRUE 653      * </pre> 654      * @see #TRUE 655      * @see #FALSE 656      * @since 3.3 657      */ 658     public final static String FORMATTER_COMMENT_FORMAT_JAVADOC_COMMENT = "org.eclipse.jdt.core.formatter.comment.format_javadoc_comments"; //$NON-NLS-1$ 659 660     /** 661      * <pre> 662      * FORMATTER / Option to control whether the header comment of a Java source file is formatted 663      * - option id: "org.eclipse.jdt.core.formatter.comment.format_header" 664      * - possible values: { TRUE, FALSE } 665      * - default: FALSE 666      * </pre> 667      * @see #TRUE 668      * @see #FALSE 669      * @since 3.1 670      */ 671     public final static String FORMATTER_COMMENT_FORMAT_HEADER = "org.eclipse.jdt.core.formatter.comment.format_header"; //$NON-NLS-1$ 672 673     /** 674      * <pre> 675      * FORMATTER / Option to control whether HTML tags are formatted. 676      * - option id: "org.eclipse.jdt.core.formatter.comment.format_html" 677      * - possible values: { TRUE, FALSE } 678      * - default: TRUE 679      * </pre> 680      * @see #TRUE 681      * @see #FALSE 682      * @since 3.1 683      */ 684     public final static String FORMATTER_COMMENT_FORMAT_HTML = "org.eclipse.jdt.core.formatter.comment.format_html"; //$NON-NLS-1$ 685 686     /** 687      * <pre> 688      * FORMATTER / Option to control whether code snippets are formatted in comments 689      * - option id: "org.eclipse.jdt.core.formatter.comment.format_source_code" 690      * - possible values: { TRUE, FALSE } 691      * - default: TRUE 692      * </pre> 693      * @see #TRUE 694      * @see #FALSE 695      * @since 3.1 696      */ 697     public final static String FORMATTER_COMMENT_FORMAT_SOURCE = "org.eclipse.jdt.core.formatter.comment.format_source_code"; //$NON-NLS-1$ 698 699     /** 700      * <pre> 701      * FORMATTER / Option to control whether description of Javadoc parameters are indented 702      * - option id: "org.eclipse.jdt.core.formatter.comment.indent_parameter_description" 703      * - possible values: { TRUE, FALSE } 704      * - default: TRUE 705      * </pre> 706      * @see #TRUE 707      * @see #FALSE 708      * @since 3.1 709      */ 710     public final static String FORMATTER_COMMENT_INDENT_PARAMETER_DESCRIPTION = "org.eclipse.jdt.core.formatter.comment.indent_parameter_description"; //$NON-NLS-1$ 711 712     /** 713      * <pre> 714      * FORMATTER / Option to control whether Javadoc root tags are indented. 715      * - option id: "org.eclipse.jdt.core.formatter.comment.indent_root_tags" 716      * - possible values: { TRUE, FALSE } 717      * - default: TRUE 718      * </pre> 719      * @see #TRUE 720      * @see #FALSE 721      * @since 3.1 722      */ 723     public final static String FORMATTER_COMMENT_INDENT_ROOT_TAGS = "org.eclipse.jdt.core.formatter.comment.indent_root_tags"; //$NON-NLS-1$ 724 725     /** 726      * <pre> 727      * FORMATTER / Option to insert an empty line before the Javadoc root tag block 728      * - option id: "org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" 729      * - possible values: { INSERT, DO_NOT_INSERT } 730      * - default: INSERT 731      * </pre> 732      * @see JavaCore#INSERT 733      * @see JavaCore#DO_NOT_INSERT 734      * @since 3.1 735      */ 736     public final static String FORMATTER_COMMENT_INSERT_EMPTY_LINE_BEFORE_ROOT_TAGS = "org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags"; //$NON-NLS-1$ 737 738     /** 739      * <pre> 740      * FORMATTER / Option to insert a new line after Javadoc root tag parameters 741      * - option id: "org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter" 742      * - possible values: { INSERT, DO_NOT_INSERT } 743      * - default: INSERT 744      * </pre> 745      * @see JavaCore#INSERT 746      * @see JavaCore#DO_NOT_INSERT 747      * @since 3.1 748      */ 749     public final static String FORMATTER_COMMENT_INSERT_NEW_LINE_FOR_PARAMETER = "org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter"; //$NON-NLS-1$ 750 751     /** 752      * <pre> 753      * FORMATTER / Option to specify the line length for comments. 754      * - option id: "org.eclipse.jdt.core.formatter.comment.line_length" 755      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 756      * - default: "80" 757      * </pre> 758      * @since 3.1 759      */ 760     public final static String FORMATTER_COMMENT_LINE_LENGTH = "org.eclipse.jdt.core.formatter.comment.line_length"; //$NON-NLS-1$ 761 762     /** 763      * <pre> 764      * FORMATTER / Option to compact else/if 765      * - option id: "org.eclipse.jdt.core.formatter.compact_else_if" 766      * - possible values: { TRUE, FALSE } 767      * - default: TRUE 768      * </pre> 769      * @see #TRUE 770      * @see #FALSE 771      * @since 3.0 772      */ 773     public static final String FORMATTER_COMPACT_ELSE_IF = JavaCore.PLUGIN_ID + ".formatter.compact_else_if"; //$NON-NLS-1$ 774 775     /** 776      * <pre> 777      * FORMATTER / Option to set the continuation indentation 778      * - option id: "org.eclipse.jdt.core.formatter.continuation_indentation" 779      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 780      * - default: "2" 781      * </pre> 782      * @since 3.0 783      */ 784     public static final String FORMATTER_CONTINUATION_INDENTATION = JavaCore.PLUGIN_ID + ".formatter.continuation_indentation"; //$NON-NLS-1$ 785 /** 786      * <pre> 787      * FORMATTER / Option to set the continuation indentation inside array initializer 788      * - option id: "org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" 789      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 790      * - default: "2" 791      * </pre> 792      * @since 3.0 793      */ 794     public static final String FORMATTER_CONTINUATION_INDENTATION_FOR_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.continuation_indentation_for_array_initializer"; //$NON-NLS-1$ 795 /** 796      * <pre> 797      * FORMATTER / Option to indent body declarations compare to its enclosing annotation declaration header 798      * - option id: "org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header" 799      * - possible values: { TRUE, FALSE } 800      * - default: TRUE 801      * </pre> 802      * @see #TRUE 803      * @see #FALSE 804      * @since 3.2 805      */ 806     public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ANNOTATION_DECLARATION_HEADER = JavaCore.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_annotation_declaration_header"; //$NON-NLS-1$ 807 /** 808      * <pre> 809      * FORMATTER / Option to indent body declarations compare to its enclosing enum constant header 810      * - option id: "org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header" 811      * - possible values: { TRUE, FALSE } 812      * - default: TRUE 813      * </pre> 814      * @see #TRUE 815      * @see #FALSE 816      * @since 3.1 817      */ 818     public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_CONSTANT_HEADER = JavaCore.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_enum_constant_header"; //$NON-NLS-1$ 819 /** 820      * <pre> 821      * FORMATTER / Option to indent body declarations compare to its enclosing enum declaration header 822      * - option id: "org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header" 823      * - possible values: { TRUE, FALSE } 824      * - default: TRUE 825      * </pre> 826      * @see #TRUE 827      * @see #FALSE 828      * @since 3.1 829      */ 830     public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_ENUM_DECLARATION_HEADER = JavaCore.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_enum_declaration_header"; //$NON-NLS-1$ 831 /** 832      * <pre> 833      * FORMATTER / Option to indent body declarations compare to its enclosing type header 834      * - option id: "org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header" 835      * - possible values: { TRUE, FALSE } 836      * - default: TRUE 837      * </pre> 838      * @see #TRUE 839      * @see #FALSE 840      * @since 3.0 841      */ 842     public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_TYPE_HEADER = JavaCore.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_type_header"; //$NON-NLS-1$ 843 /** 844      * <pre> 845      * FORMATTER / Option to indent breaks compare to cases 846      * - option id: "org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases" 847      * - possible values: { TRUE, FALSE } 848      * - default: TRUE 849      * </pre> 850      * @see #TRUE 851      * @see #FALSE 852      * @since 3.0 853      */ 854     public static final String FORMATTER_INDENT_BREAKS_COMPARE_TO_CASES = JavaCore.PLUGIN_ID + ".formatter.indent_breaks_compare_to_cases"; //$NON-NLS-1$ 855 /** 856      * <pre> 857      * FORMATTER / Option to indent empty lines 858      * - option id: "org.eclipse.jdt.core.formatter.indent_empty_lines" 859      * - possible values: { TRUE, FALSE } 860      * - default: FALSE 861      * </pre> 862      * @see #TRUE 863      * @see #FALSE 864      * @since 3.2 865      */ 866     public static final String FORMATTER_INDENT_EMPTY_LINES = JavaCore.PLUGIN_ID + ".formatter.indent_empty_lines"; //$NON-NLS-1$ 867 /** 868      * <pre> 869      * FORMATTER / Option to indent statements inside a block 870      * - option id: "org.eclipse.jdt.core.formatter.indent_statements_compare_to_block" 871      * - possible values: { TRUE, FALSE } 872      * - default: TRUE 873      * </pre> 874      * @see #TRUE 875      * @see #FALSE 876      * @since 3.0 877      */ 878     public static final String FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK = JavaCore.PLUGIN_ID + ".formatter.indent_statements_compare_to_block"; //$NON-NLS-1$ 879 /** 880      * <pre> 881      * FORMATTER / Option to indent statements inside the body of a method or a constructor 882      * - option id: "org.eclipse.jdt.core.formatter.indent_statements_compare_to_body" 883      * - possible values: { TRUE, FALSE } 884      * - default: TRUE 885      * </pre> 886      * @see #TRUE 887      * @see #FALSE 888      * @since 3.0 889      */ 890     public static final String FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY = JavaCore.PLUGIN_ID + ".formatter.indent_statements_compare_to_body"; //$NON-NLS-1$ 891 /** 892      * <pre> 893      * FORMATTER / Option to indent switch statements compare to cases 894      * - option id: "org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases" 895      * - possible values: { TRUE, FALSE } 896      * - default: TRUE 897      * </pre> 898      * @see #TRUE 899      * @see #FALSE 900      * @since 3.0 901      */ 902     public static final String FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES = JavaCore.PLUGIN_ID + ".formatter.indent_switchstatements_compare_to_cases"; //$NON-NLS-1$ 903 /** 904      * <pre> 905      * FORMATTER / Option to indent switch statements compare to switch 906      * - option id: "org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch" 907      * - possible values: { TRUE, FALSE } 908      * - default: TRUE 909      * </pre> 910      * @see #TRUE 911      * @see #FALSE 912      * @since 3.0 913      */ 914     public static final String FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH = JavaCore.PLUGIN_ID + ".formatter.indent_switchstatements_compare_to_switch"; //$NON-NLS-1$ 915 916     /** 917      * <pre> 918      * FORMATTER / Option to specify the equivalent number of spaces that represents one indentation 919      * - option id: "org.eclipse.jdt.core.formatter.indentation.size" 920      * - possible values: "&lt;n&gt;", where n is zero or a positive integer 921      * - default: "4" 922      * </pre> 923      * <p>This option is used only if the tab char is set to MIXED. 924      * </p> 925      * @see #FORMATTER_TAB_CHAR 926      * @since 3.1 927      */ 928     public static final String FORMATTER_INDENTATION_SIZE = JavaCore.PLUGIN_ID + ".formatter.indentation.size"; //$NON-NLS-1$ 929 930     /** 931      * <pre> 932      * FORMATTER / Option to insert a new line after an annotation 933      * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_annotation" 934      * - possible values: { INSERT, DO_NOT_INSERT } 935      * - default: INSERT 936      * </pre> 937      * @see JavaCore#INSERT 938      * @see JavaCore#DO_NOT_INSERT 939      * @since 3.1 940      */ 941     public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_annotation";//$NON-NLS-1$ 942 943     /** 944      * <pre> 945      * FORMATTER / Option to insert a new line after the opening brace in an array initializer 946      * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" 947      * - possible values: { INSERT, DO_NOT_INSERT } 948      * - default: DO_NOT_INSERT 949      * </pre> 950      * @see JavaCore#INSERT 951      * @see JavaCore#DO_NOT_INSERT 952      * @since 3.0 953      */ 954     public static final String FORMATTER_INSERT_NEW_LINE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_opening_brace_in_array_initializer";//$NON-NLS-1$ 955 956     /** 957      * <pre> 958      * FORMATTER / Option to insert a new line at the end of the current file if missing 959      * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing" 960      * - possible values: { INSERT, DO_NOT_INSERT } 961      * - default: DO_NOT_INSERT 962      * </pre> 963      * @see JavaCore#INSERT 964      * @see JavaCore#DO_NOT_INSERT 965      * @since 3.1 966      */ 967     public static final String FORMATTER_INSERT_NEW_LINE_AT_END_OF_FILE_IF_MISSING = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_at_end_of_file_if_missing";//$NON-NLS-1$ 968 /** 969      * <pre> 970      * FORMATTER / Option to insert a new line before the catch keyword in try statement 971      * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement" 972      * - possible values: { INSERT, DO_NOT_INSERT } 973      * - default: DO_NOT_INSERT 974      * </pre> 975      * @see JavaCore#INSERT 976      * @see JavaCore#DO_NOT_INSERT 977      * @since 3.0 978      */ 979     public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_before_catch_in_try_statement"; //$NON-NLS-1$ 980 /** 981      * <pre> 982      * FORMATTER / Option to insert a new line before the closing brace in an array initializer 983      * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" 984      * - possible values: { INSERT, DO_NOT_INSERT } 985      * - default: DO_NOT_INSERT 986      * </pre> 987      * @see JavaCore#INSERT 988      * @see JavaCore#DO_NOT_INSERT 989      * @since 3.0 990      */ 991     public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_before_closing_brace_in_array_initializer";//$NON-NLS-1$ 992 /** 993      * <pre> 994      * FORMATTER / Option to insert a new line before the else keyword in if statement 995      * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement" 996      * - possible values: { INSERT, DO_NOT_INSERT } 997      * - default: DO_NOT_INSERT 998      * </pre> 999      * @see JavaCore#INSERT 1000     * @see JavaCore#DO_NOT_INSERT 1001     * @since 3.0 1002     */ 1003    public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_before_else_in_if_statement"; //$NON-NLS-1$ 1004 /** 1005     * <pre> 1006     * FORMATTER / Option to insert a new line before the finally keyword in try statement 1007     * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement" 1008     * - possible values: { INSERT, DO_NOT_INSERT } 1009     * - default: DO_NOT_INSERT 1010     * </pre> 1011     * @see JavaCore#INSERT 1012     * @see JavaCore#DO_NOT_INSERT 1013     * @since 3.0 1014     */ 1015    public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_before_finally_in_try_statement"; //$NON-NLS-1$ 1016 /** 1017     * <pre> 1018     * FORMATTER / Option to insert a new line before while in do statement 1019     * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement" 1020     * - possible values: { INSERT, DO_NOT_INSERT } 1021     * - default: DO_NOT_INSERT 1022     * </pre> 1023     * @see JavaCore#INSERT 1024     * @see JavaCore#DO_NOT_INSERT 1025     * @since 3.0 1026     */ 1027    public static final String FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_before_while_in_do_statement"; //$NON-NLS-1$ 1028 /** 1029     * <pre> 1030     * FORMATTER / Option to insert a new line in an empty annotation declaration 1031     * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration" 1032     * - possible values: { INSERT, DO_NOT_INSERT } 1033     * - default: INSERT 1034     * </pre> 1035     * @see JavaCore#INSERT 1036     * @see JavaCore#DO_NOT_INSERT 1037     * @since 3.2 1038     */ 1039    public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ANNOTATION_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_in_empty_annotation_declaration"; //$NON-NLS-1$ 1040 /** 1041     * <pre> 1042     * FORMATTER / Option to insert a new line in an empty anonymous type declaration 1043     * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration" 1044     * - possible values: { INSERT, DO_NOT_INSERT } 1045     * - default: INSERT 1046     * </pre> 1047     * @see JavaCore#INSERT 1048     * @see JavaCore#DO_NOT_INSERT 1049     * @since 3.0 1050     */ 1051    public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ANONYMOUS_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_in_empty_anonymous_type_declaration"; //$NON-NLS-1$ 1052 /** 1053     * <pre> 1054     * FORMATTER / Option to insert a new line in an empty block 1055     * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block" 1056     * - possible values: { INSERT, DO_NOT_INSERT } 1057     * - default: INSERT 1058     * </pre> 1059     * @see JavaCore#INSERT 1060     * @see JavaCore#DO_NOT_INSERT 1061     * @since 3.0 1062     */ 1063    public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_in_empty_block"; //$NON-NLS-1$ 1064 /** 1065     * <pre> 1066     * FORMATTER / Option to insert a new line in an empty enum constant 1067     * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant" 1068     * - possible values: { INSERT, DO_NOT_INSERT } 1069     * - default: INSERT 1070     * </pre> 1071     * @see JavaCore#INSERT 1072     * @see JavaCore#DO_NOT_INSERT 1073     * @since 3.1 1074     */ 1075    public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_in_empty_enum_constant"; //$NON-NLS-1$ 1076 /** 1077     * <pre> 1078     * FORMATTER / Option to insert a new line in an empty enum declaration 1079     * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration" 1080     * - possible values: { INSERT, DO_NOT_INSERT } 1081     * - default: INSERT 1082     * </pre> 1083     * @see JavaCore#INSERT 1084     * @see JavaCore#DO_NOT_INSERT 1085     * @since 3.1 1086     */ 1087    public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_ENUM_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_in_empty_enum_declaration"; //$NON-NLS-1$ 1088 /** 1089     * <pre> 1090     * FORMATTER / Option to insert a new line in an empty method body 1091     * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body" 1092     * - possible values: { INSERT, DO_NOT_INSERT } 1093     * - default: INSERT 1094     * </pre> 1095     * @see JavaCore#INSERT 1096     * @see JavaCore#DO_NOT_INSERT 1097     * @since 3.0 1098     */ 1099    public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_METHOD_BODY = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_in_empty_method_body"; //$NON-NLS-1$ 1100 /** 1101     * <pre> 1102     * FORMATTER / Option to insert a new line in an empty type declaration 1103     * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration" 1104     * - possible values: { INSERT, DO_NOT_INSERT } 1105     * - default: INSERT 1106     * </pre> 1107     * @see JavaCore#INSERT 1108     * @see JavaCore#DO_NOT_INSERT 1109     * @since 3.0 1110     */ 1111    public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_in_empty_type_declaration"; //$NON-NLS-1$ 1112 /** 1113     * <pre> 1114     * FORMATTER / Option to insert a space after and in wilcard 1115     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter" 1116     * - possible values: { INSERT, DO_NOT_INSERT } 1117     * - default: INSERT 1118     * </pre> 1119     * @see JavaCore#INSERT 1120     * @see JavaCore#DO_NOT_INSERT 1121     * @since 3.1 1122     */ 1123    public static final String FORMATTER_INSERT_SPACE_AFTER_AND_IN_TYPE_PARAMETER = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_and_in_type_parameter"; //$NON-NLS-1$ 1124 /** 1125     * <pre> 1126     * FORMATTER / Option to insert a space after an assignment operator 1127     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator" 1128     * - possible values: { INSERT, DO_NOT_INSERT } 1129     * - default: INSERT 1130     * </pre> 1131     * @see JavaCore#INSERT 1132     * @see JavaCore#DO_NOT_INSERT 1133     * @since 3.0 1134     */ 1135    public static final String FORMATTER_INSERT_SPACE_AFTER_ASSIGNMENT_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_assignment_operator"; //$NON-NLS-1$ 1136 /** 1137     * <pre> 1138     * FORMATTER / Option to insert a space after at in annotation 1139     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation" 1140     * - possible values: { INSERT, DO_NOT_INSERT } 1141     * - default: INSERT 1142     * </pre> 1143     * @see JavaCore#INSERT 1144     * @see JavaCore#DO_NOT_INSERT 1145     * @since 3.1 1146     */ 1147    public static final String FORMATTER_INSERT_SPACE_AFTER_AT_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_at_in_annotation"; //$NON-NLS-1$ 1148 /** 1149     * <pre> 1150     * FORMATTER / Option to insert a space after at in annotation type declaration 1151     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration" 1152     * - possible values: { INSERT, DO_NOT_INSERT } 1153     * - default: DO_NOT_INSERT 1154     * </pre> 1155     * @see JavaCore#INSERT 1156     * @see JavaCore#DO_NOT_INSERT 1157     * @since 3.1 1158     */ 1159    public static final String FORMATTER_INSERT_SPACE_AFTER_AT_IN_ANNOTATION_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_at_in_annotation_type_declaration"; //$NON-NLS-1$ 1160 /** 1161     * <pre> 1162     * FORMATTER / Option to insert a space after a binary operator 1163     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_binary_operator" 1164     * - possible values: { INSERT, DO_NOT_INSERT } 1165     * - default: INSERT 1166     * </pre> 1167     * @see JavaCore#INSERT 1168     * @see JavaCore#DO_NOT_INSERT 1169     * @since 3.0 1170     */ 1171    public static final String FORMATTER_INSERT_SPACE_AFTER_BINARY_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_binary_operator"; //$NON-NLS-1$ 1172 /** 1173     * <pre> 1174     * FORMATTER / Option to insert a space after the closing angle bracket in type arguments 1175     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments" 1176     * - possible values: { INSERT, DO_NOT_INSERT } 1177     * - default: INSERT 1178     * </pre> 1179     * @see JavaCore#INSERT 1180     * @see JavaCore#DO_NOT_INSERT 1181     * @since 3.1 1182     */ 1183    public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_closing_angle_bracket_in_type_arguments"; //$NON-NLS-1$ 1184 /** 1185     * <pre> 1186     * FORMATTER / Option to insert a space after the closing angle bracket in type parameters 1187     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters" 1188     * - possible values: { INSERT, DO_NOT_INSERT } 1189     * - default: INSERT 1190     * </pre> 1191     * @see JavaCore#INSERT 1192     * @see JavaCore#DO_NOT_INSERT 1193     * @since 3.1 1194     */ 1195    public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_closing_angle_bracket_in_type_parameters"; //$NON-NLS-1$ 1196 /** 1197     * <pre> 1198     * FORMATTER / Option to insert a space after the closing brace of a block 1199     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" 1200     * - possible values: { INSERT, DO_NOT_INSERT } 1201     * - default: INSERT 1202     * </pre> 1203     * @see JavaCore#INSERT 1204     * @see JavaCore#DO_NOT_INSERT 1205     * @since 3.0 1206     */ 1207    public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_BRACE_IN_BLOCK = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_closing_brace_in_block"; //$NON-NLS-1$ 1208 /** 1209     * <pre> 1210     * FORMATTER / Option to insert a space after the closing parenthesis of a cast expression 1211     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast" 1212     * - possible values: { INSERT, DO_NOT_INSERT } 1213     * - default: INSERT 1214     * </pre> 1215     * @see JavaCore#INSERT 1216     * @see JavaCore#DO_NOT_INSERT 1217     * @since 3.0 1218     */ 1219    public static final String FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_closing_paren_in_cast"; //$NON-NLS-1$ 1220 /** 1221     * <pre> 1222     * FORMATTER / Option to insert a space after the colon in an assert statement 1223     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert" 1224     * - possible values: { INSERT, DO_NOT_INSERT } 1225     * - default: INSERT 1226     * </pre> 1227     * @see JavaCore#INSERT 1228     * @see JavaCore#DO_NOT_INSERT 1229     * @since 3.0 1230     */ 1231    public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_ASSERT = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_colon_in_assert"; //$NON-NLS-1$ 1232 /** 1233     * <pre> 1234     * FORMATTER / Option to insert a space after colon in a case statement when a opening brace follows the colon 1235     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case" 1236     * - possible values: { INSERT, DO_NOT_INSERT } 1237     * - default: INSERT 1238     * </pre> 1239     * @see JavaCore#INSERT 1240     * @see JavaCore#DO_NOT_INSERT 1241     * @since 3.0 1242     */ 1243    public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CASE = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_colon_in_case"; //$NON-NLS-1$ 1244 /** 1245     * <pre> 1246     * FORMATTER / Option to insert a space after the colon in a conditional expression 1247     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional" 1248     * - possible values: { INSERT, DO_NOT_INSERT } 1249     * - default: INSERT 1250     * </pre> 1251     * @see JavaCore#INSERT 1252     * @see JavaCore#DO_NOT_INSERT 1253     * @since 3.0 1254     */ 1255    public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CONDITIONAL = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_colon_in_conditional"; //$NON-NLS-1$ 1256 /** 1257     * <pre> 1258     * FORMATTER / Option to insert a space after colon in a for statement 1259     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for" 1260     * - possible values: { INSERT, DO_NOT_INSERT } 1261     * - default: INSERT 1262     * </pre> 1263     * @see JavaCore#INSERT 1264     * @see JavaCore#DO_NOT_INSERT 1265     * @since 3.1 1266     */ 1267    public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_colon_in_for"; //$NON-NLS-1$ 1268 /** 1269     * <pre> 1270     * FORMATTER / Option to insert a space after the colon in a labeled statement 1271     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement" 1272     * - possible values: { INSERT, DO_NOT_INSERT } 1273     * - default: INSERT 1274     * </pre> 1275     * @see JavaCore#INSERT 1276     * @see JavaCore#DO_NOT_INSERT 1277     * @since 3.0 1278     */ 1279    public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_LABELED_STATEMENT = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_colon_in_labeled_statement"; //$NON-NLS-1$ 1280 /** 1281     * <pre> 1282     * FORMATTER / Option to insert a space after the comma in an allocation expression 1283     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" 1284     * - possible values: { INSERT, DO_NOT_INSERT } 1285     * - default: INSERT 1286     * </pre> 1287     * @see JavaCore#INSERT 1288     * @see JavaCore#DO_NOT_INSERT 1289     * @since 3.0 1290     */ 1291    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ALLOCATION_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_allocation_expression"; //$NON-NLS-1$ 1292 /** 1293     * <pre> 1294     * FORMATTER / Option to insert a space after the comma in annotation 1295     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation" 1296     * - possible values: { INSERT, DO_NOT_INSERT } 1297     * - default: INSERT 1298     * </pre> 1299     * @see JavaCore#INSERT 1300     * @see JavaCore#DO_NOT_INSERT 1301     * @since 3.1 1302     */ 1303    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_annotation"; //$NON-NLS-1$ 1304 /** 1305     * <pre> 1306     * FORMATTER / Option to insert a space after the comma in an array initializer 1307     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer" 1308     * - possible values: { INSERT, DO_NOT_INSERT } 1309     * - default: INSERT 1310     * </pre> 1311     * @see JavaCore#INSERT 1312     * @see JavaCore#DO_NOT_INSERT 1313     * @since 3.0 1314     */ 1315    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_array_initializer"; //$NON-NLS-1$ 1316 /** 1317     * <pre> 1318     * FORMATTER / Option to insert a space after the comma in the parameters of a constructor declaration 1319     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters" 1320     * - possible values: { INSERT, DO_NOT_INSERT } 1321     * - default: INSERT 1322     * </pre> 1323     * @see JavaCore#INSERT 1324     * @see JavaCore#DO_NOT_INSERT 1325     * @since 3.0 1326     */ 1327    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_constructor_declaration_parameters"; //$NON-NLS-1$ 1328 /** 1329     * <pre> 1330     * FORMATTER / Option to insert a space after the comma in the exception names in a throws clause of a constructor declaration 1331     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws" 1332     * - possible values: { INSERT, DO_NOT_INSERT } 1333     * - default: INSERT 1334     * </pre> 1335     * @see JavaCore#INSERT 1336     * @see JavaCore#DO_NOT_INSERT 1337     * @since 3.0 1338     */ 1339    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_constructor_declaration_throws"; //$NON-NLS-1$ 1340 /** 1341     * <pre> 1342     * FORMATTER / Option to insert a space after the comma in the arguments of an enum constant 1343     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments" 1344     * - possible values: { INSERT, DO_NOT_INSERT } 1345     * - default: INSERT 1346     * </pre> 1347     * @see JavaCore#INSERT 1348     * @see JavaCore#DO_NOT_INSERT 1349     * @since 3.1 1350     */ 1351    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_CONSTANT_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_enum_constant_arguments"; //$NON-NLS-1$ 1352 /** 1353     * <pre> 1354     * FORMATTER / Option to insert a space after the comma in enum declarations 1355     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations" 1356     * - possible values: { INSERT, DO_NOT_INSERT } 1357     * - default: INSERT 1358     * </pre> 1359     * @see JavaCore#INSERT 1360     * @see JavaCore#DO_NOT_INSERT 1361     * @since 3.1 1362     */ 1363    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ENUM_DECLARATIONS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_enum_declarations"; //$NON-NLS-1$ 1364 /** 1365     * <pre> 1366     * FORMATTER / Option to insert a space after the comma in the arguments of an explicit constructor call 1367     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments" 1368     * - possible values: { INSERT, DO_NOT_INSERT } 1369     * - default: INSERT 1370     * </pre> 1371     * @see JavaCore#INSERT 1372     * @see JavaCore#DO_NOT_INSERT 1373     * @since 3.0 1374     */ 1375    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_explicitconstructorcall_arguments"; //$NON-NLS-1$ 1376 /** 1377     * <pre> 1378     * FORMATTER / Option to insert a space after the comma in the increments of a for statement 1379     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments" 1380     * - possible values: { INSERT, DO_NOT_INSERT } 1381     * - default: INSERT 1382     * </pre> 1383     * @see JavaCore#INSERT 1384     * @see JavaCore#DO_NOT_INSERT 1385     * @since 3.0 1386     */ 1387    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INCREMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_for_increments"; //$NON-NLS-1$ 1388 /** 1389     * <pre> 1390     * FORMATTER / Option to insert a space after the comma in the initializations of a for statement 1391     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits" 1392     * - possible values: { INSERT, DO_NOT_INSERT } 1393     * - default: INSERT 1394     * </pre> 1395     * @see JavaCore#INSERT 1396     * @see JavaCore#DO_NOT_INSERT 1397     * @since 3.0 1398     */ 1399    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_FOR_INITS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_for_inits"; //$NON-NLS-1$ 1400 /** 1401     * <pre> 1402     * FORMATTER / Option to insert a space after the comma in the parameters of a method declaration 1403     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" 1404     * - possible values: { INSERT, DO_NOT_INSERT } 1405     * - default: INSERT 1406     * </pre> 1407     * @see JavaCore#INSERT 1408     * @see JavaCore#DO_NOT_INSERT 1409     * @since 3.0 1410     */ 1411    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_declaration_parameters"; //$NON-NLS-1$ 1412 /** 1413     * <pre> 1414     * FORMATTER / Option to insert a space after the comma in the exception names in a throws clause of a method declaration 1415     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws" 1416     * - possible values: { INSERT, DO_NOT_INSERT } 1417     * - default: INSERT 1418     * </pre> 1419     * @see JavaCore#INSERT 1420     * @see JavaCore#DO_NOT_INSERT 1421     * @since 3.0 1422     */ 1423    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_DECLARATION_THROWS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_declaration_throws"; //$NON-NLS-1$ 1424 /** 1425     * <pre> 1426     * FORMATTER / Option to insert a space after the comma in the arguments of a method invocation 1427     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" 1428     * - possible values: { INSERT, DO_NOT_INSERT } 1429     * - default: INSERT 1430     * </pre> 1431     * @see JavaCore#INSERT 1432     * @see JavaCore#DO_NOT_INSERT 1433     * @since 3.0 1434     */ 1435    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_METHOD_INVOCATION_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_method_invocation_arguments"; //$NON-NLS-1$ 1436 /** 1437     * <pre> 1438     * FORMATTER / Option to insert a space after the comma in multiple field declaration 1439     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations" 1440     * - possible values: { INSERT, DO_NOT_INSERT } 1441     * - default: INSERT 1442     * </pre> 1443     * @see JavaCore#INSERT 1444     * @see JavaCore#DO_NOT_INSERT 1445     * @since 3.0 1446     */ 1447    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_multiple_field_declarations"; //$NON-NLS-1$ 1448 /** 1449     * <pre> 1450     * FORMATTER / Option to insert a space after the comma in multiple local declaration 1451     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations" 1452     * - possible values: { INSERT, DO_NOT_INSERT } 1453     * - default: INSERT 1454     * </pre> 1455     * @see JavaCore#INSERT 1456     * @see JavaCore#DO_NOT_INSERT 1457     * @since 3.0 1458     */ 1459    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_multiple_local_declarations"; //$NON-NLS-1$ 1460 /** 1461     * <pre> 1462     * FORMATTER / Option to insert a space after the comma in parameterized type reference 1463     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference" 1464     * - possible values: { INSERT, DO_NOT_INSERT } 1465     * - default: INSERT 1466     * </pre> 1467     * @see JavaCore#INSERT 1468     * @see JavaCore#DO_NOT_INSERT 1469     * @since 3.1 1470     */ 1471    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_parameterized_type_reference"; //$NON-NLS-1$ 1472 /** 1473     * <pre> 1474     * FORMATTER / Option to insert a space after the comma in superinterfaces names of a type header 1475     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces" 1476     * - possible values: { INSERT, DO_NOT_INSERT } 1477     * - default: INSERT 1478     * </pre> 1479     * @see JavaCore#INSERT 1480     * @see JavaCore#DO_NOT_INSERT 1481     * @since 3.0 1482     */ 1483    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_SUPERINTERFACES = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_superinterfaces"; //$NON-NLS-1$ 1484 /** 1485     * <pre> 1486     * FORMATTER / Option to insert a space after the comma in type arguments 1487     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments" 1488     * - possible values: { INSERT, DO_NOT_INSERT } 1489     * - default: INSERT 1490     * </pre> 1491     * @see JavaCore#INSERT 1492     * @see JavaCore#DO_NOT_INSERT 1493     * @since 3.1 1494     */ 1495    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_type_arguments"; //$NON-NLS-1$ 1496 /** 1497     * <pre> 1498     * FORMATTER / Option to insert a space after the comma in type parameters 1499     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters" 1500     * - possible values: { INSERT, DO_NOT_INSERT } 1501     * - default: INSERT 1502     * </pre> 1503     * @see JavaCore#INSERT 1504     * @see JavaCore#DO_NOT_INSERT 1505     * @since 3.1 1506     */ 1507    public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_TYPE_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_type_parameters"; //$NON-NLS-1$ 1508 /** 1509     * <pre> 1510     * FORMATTER / Option to insert a space after ellipsis 1511     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_ellipsis" 1512     * - possible values: { INSERT, DO_NOT_INSERT } 1513     * - default: INSERT 1514     * </pre> 1515     * @see JavaCore#INSERT 1516     * @see JavaCore#DO_NOT_INSERT 1517     * @since 3.1 1518     */ 1519    public static final String FORMATTER_INSERT_SPACE_AFTER_ELLIPSIS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_ellipsis"; //$NON-NLS-1$ 1520 /** 1521     * <pre> 1522     * FORMATTER / Option to insert a space after the opening angle bracket in parameterized type reference 1523     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference" 1524     * - possible values: { INSERT, DO_NOT_INSERT } 1525     * - default: DO_NOT_INSERT 1526     * </pre> 1527     * @see JavaCore#INSERT 1528     * @see JavaCore#DO_NOT_INSERT 1529     * @since 3.1 1530     */ 1531    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference";//$NON-NLS-1$ 1532 /** 1533     * <pre> 1534     * FORMATTER / Option to insert a space after the opening angle bracket in type arguments 1535     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments" 1536     * - possible values: { INSERT, DO_NOT_INSERT } 1537     * - default: DO_NOT_INSERT 1538     * </pre> 1539     * @see JavaCore#INSERT 1540     * @see JavaCore#DO_NOT_INSERT 1541     * @since 3.1 1542     */ 1543    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_type_arguments";//$NON-NLS-1$ 1544 /** 1545     * <pre> 1546     * FORMATTER / Option to insert a space after the opening angle bracket in type parameters 1547     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters" 1548     * - possible values: { INSERT, DO_NOT_INSERT } 1549     * - default: DO_NOT_INSERT 1550     * </pre> 1551     * @see JavaCore#INSERT 1552     * @see JavaCore#DO_NOT_INSERT 1553     * @since 3.1 1554     */ 1555    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_angle_bracket_in_type_parameters";//$NON-NLS-1$ 1556 /** 1557     * <pre> 1558     * FORMATTER / Option to insert a space after the opening brace in an array initializer 1559     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" 1560     * - possible values: { INSERT, DO_NOT_INSERT } 1561     * - default: DO_NOT_INSERT 1562     * </pre> 1563     * @see JavaCore#INSERT 1564     * @see JavaCore#DO_NOT_INSERT 1565     * @since 3.0 1566     */ 1567    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_brace_in_array_initializer"; //$NON-NLS-1$ 1568 /** 1569     * <pre> 1570     * FORMATTER / Option to insert a space after the opening bracket inside an array allocation expression 1571     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression" 1572     * - possible values: { INSERT, DO_NOT_INSERT } 1573     * - default: DO_NOT_INSERT 1574     * </pre> 1575     * @see JavaCore#INSERT 1576     * @see JavaCore#DO_NOT_INSERT 1577     * @since 3.0 1578     */ 1579    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_bracket_in_array_allocation_expression";//$NON-NLS-1$ 1580 /** 1581     * <pre> 1582     * FORMATTER / Option to insert a space after the opening bracket inside an array reference 1583     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference" 1584     * - possible values: { INSERT, DO_NOT_INSERT } 1585     * - default: DO_NOT_INSERT 1586     * </pre> 1587     * @see JavaCore#INSERT 1588     * @see JavaCore#DO_NOT_INSERT 1589     * @since 3.0 1590     */ 1591    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_BRACKET_IN_ARRAY_REFERENCE = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_bracket_in_array_reference";//$NON-NLS-1$ 1592 /** 1593     * <pre> 1594     * FORMATTER / Option to insert a space after the opening parenthesis in annotation 1595     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation" 1596     * - possible values: { INSERT, DO_NOT_INSERT } 1597     * - default: DO_NOT_INSERT 1598     * </pre> 1599     * @see JavaCore#INSERT 1600     * @see JavaCore#DO_NOT_INSERT 1601     * @since 3.1 1602     */ 1603    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_annotation"; //$NON-NLS-1$ 1604 /** 1605     * <pre> 1606     * FORMATTER / Option to insert a space after the opening parenthesis in a cast expression 1607     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast" 1608     * - possible values: { INSERT, DO_NOT_INSERT } 1609     * - default: DO_NOT_INSERT 1610     * </pre> 1611     * @see JavaCore#INSERT 1612     * @see JavaCore#DO_NOT_INSERT 1613     * @since 3.0 1614     */ 1615    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CAST = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_cast"; //$NON-NLS-1$ 1616 /** 1617     * <pre> 1618     * FORMATTER / Option to insert a space after the opening parenthesis in a catch 1619     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch" 1620     * - possible values: { INSERT, DO_NOT_INSERT } 1621     * - default: DO_NOT_INSERT 1622     * </pre> 1623     * @see JavaCore#INSERT 1624     * @see JavaCore#DO_NOT_INSERT 1625     * @since 3.0 1626     */ 1627    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CATCH = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_catch"; //$NON-NLS-1$ 1628 /** 1629     * <pre> 1630     * FORMATTER / Option to insert a space after the opening parenthesis in a constructor declaration 1631     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration" 1632     * - possible values: { INSERT, DO_NOT_INSERT } 1633     * - default: DO_NOT_INSERT 1634     * </pre> 1635     * @see JavaCore#INSERT 1636     * @see JavaCore#DO_NOT_INSERT 1637     * @since 3.0 1638     */ 1639    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_constructor_declaration"; //$NON-NLS-1$ 1640 /** 1641     * <pre> 1642     * FORMATTER / Option to insert a space after the opening parenthesis in enum constant 1643     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant" 1644     * - possible values: { INSERT, DO_NOT_INSERT } 1645     * - default: DO_NOT_INSERT 1646     * </pre> 1647     * @see JavaCore#INSERT 1648     * @see JavaCore#DO_NOT_INSERT 1649     * @since 3.1 1650     */ 1651    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_enum_constant"; //$NON-NLS-1$ 1652 /** 1653     * <pre> 1654     * FORMATTER / Option to insert a space after the opening parenthesis in a for statement 1655     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for" 1656     * - possible values: { INSERT, DO_NOT_INSERT } 1657     * - default: DO_NOT_INSERT 1658     * </pre> 1659     * @see JavaCore#INSERT 1660     * @see JavaCore#DO_NOT_INSERT 1661     * @since 3.0 1662     */ 1663    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_for"; //$NON-NLS-1$ 1664 /** 1665     * <pre> 1666     * FORMATTER / Option to insert a space after the opening parenthesis in an if statement 1667     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if" 1668     * - possible values: { INSERT, DO_NOT_INSERT } 1669     * - default: DO_NOT_INSERT 1670     * </pre> 1671     * @see JavaCore#INSERT 1672     * @see JavaCore#DO_NOT_INSERT 1673     * @since 3.0 1674     */ 1675    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_IF = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_if"; //$NON-NLS-1$ 1676 /** 1677     * <pre> 1678     * FORMATTER / Option to insert a space after the opening parenthesis in a method declaration 1679     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" 1680     * - possible values: { INSERT, DO_NOT_INSERT } 1681     * - default: DO_NOT_INSERT 1682     * </pre> 1683     * @see JavaCore#INSERT 1684     * @see JavaCore#DO_NOT_INSERT 1685     * @since 3.0 1686     */ 1687    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_method_declaration"; //$NON-NLS-1$ 1688 /** 1689     * <pre> 1690     * FORMATTER / Option to insert a space after the opening parenthesis in a method invocation 1691     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" 1692     * - possible values: { INSERT, DO_NOT_INSERT } 1693     * - default: DO_NOT_INSERT 1694     * </pre> 1695     * @see JavaCore#INSERT 1696     * @see JavaCore#DO_NOT_INSERT 1697     * @since 3.0 1698     */ 1699    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_METHOD_INVOCATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_method_invocation"; //$NON-NLS-1$ 1700 /** 1701     * <pre> 1702     * FORMATTER / Option to insert a space after the opening parenthesis in a parenthesized expression 1703     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression" 1704     * - possible values: { INSERT, DO_NOT_INSERT } 1705     * - default: DO_NOT_INSERT 1706     * </pre> 1707     * @see JavaCore#INSERT 1708     * @see JavaCore#DO_NOT_INSERT 1709     * @since 3.0 1710     */ 1711    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_parenthesized_expression"; //$NON-NLS-1$ 1712 /** 1713     * <pre> 1714     * FORMATTER / Option to insert a space after the opening parenthesis in a switch statement 1715     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch" 1716     * - possible values: { INSERT, DO_NOT_INSERT } 1717     * - default: DO_NOT_INSERT 1718     * </pre> 1719     * @see JavaCore#INSERT 1720     * @see JavaCore#DO_NOT_INSERT 1721     * @since 3.0 1722     */ 1723    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SWITCH = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_switch"; //$NON-NLS-1$ 1724 /** 1725     * <pre> 1726     * FORMATTER / Option to insert a space after the opening parenthesis in a synchronized statement 1727     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized" 1728     * - possible values: { INSERT, DO_NOT_INSERT } 1729     * - default: DO_NOT_INSERT 1730     * </pre> 1731     * @see JavaCore#INSERT 1732     * @see JavaCore#DO_NOT_INSERT 1733     * @since 3.0 1734     */ 1735    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_SYNCHRONIZED = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_synchronized"; //$NON-NLS-1$ 1736 /** 1737     * <pre> 1738     * FORMATTER / Option to insert a space after the opening parenthesis in a while statement 1739     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while" 1740     * - possible values: { INSERT, DO_NOT_INSERT } 1741     * - default: DO_NOT_INSERT 1742     * </pre> 1743     * @see JavaCore#INSERT 1744     * @see JavaCore#DO_NOT_INSERT 1745     * @since 3.0 1746     */ 1747    public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_WHILE = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_while"; //$NON-NLS-1$ 1748 /** 1749     * <pre> 1750     * FORMATTER / Option to insert a space after a postfix operator 1751     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator" 1752     * - possible values: { INSERT, DO_NOT_INSERT } 1753     * - default: DO_NOT_INSERT 1754     * </pre> 1755     * @see JavaCore#INSERT 1756     * @see JavaCore#DO_NOT_INSERT 1757     * @since 3.0 1758     */ 1759    public static final String FORMATTER_INSERT_SPACE_AFTER_POSTFIX_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_postfix_operator"; //$NON-NLS-1$ 1760 /** 1761     * <pre> 1762     * FORMATTER / Option to insert a space after a prefix operator 1763     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator" 1764     * - possible values: { INSERT, DO_NOT_INSERT } 1765     * - default: DO_NOT_INSERT 1766     * </pre> 1767     * @see JavaCore#INSERT 1768     * @see JavaCore#DO_NOT_INSERT 1769     * @since 3.0 1770     */ 1771    public static final String FORMATTER_INSERT_SPACE_AFTER_PREFIX_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_prefix_operator"; //$NON-NLS-1$ 1772 /** 1773     * <pre> 1774     * FORMATTER / Option to insert a space after question mark in a conditional expression 1775     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional" 1776     * - possible values: { INSERT, DO_NOT_INSERT } 1777     * - default: DO_NOT_INSERT 1778     * </pre> 1779     * @see JavaCore#INSERT 1780     * @see JavaCore#DO_NOT_INSERT 1781     * @since 3.0 1782     */ 1783    public static final String FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_CONDITIONAL = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_question_in_conditional"; //$NON-NLS-1$ 1784 /** 1785     * <pre> 1786     * FORMATTER / Option to insert a space after question mark in a wildcard 1787     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard" 1788     * - possible values: { INSERT, DO_NOT_INSERT } 1789     * - default: DO_NOT_INSERT 1790     * </pre> 1791     * @see JavaCore#INSERT 1792     * @see JavaCore#DO_NOT_INSERT 1793     * @since 3.1 1794     */ 1795    public static final String FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_WILDCARD = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_question_in_wildcard"; //$NON-NLS-1$ 1796 /** 1797     * <pre> 1798     * FORMATTER / Option to insert a space after semicolon in a for statement 1799     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for" 1800     * - possible values: { INSERT, DO_NOT_INSERT } 1801     * - default: INSERT 1802     * </pre> 1803     * @see JavaCore#INSERT 1804     * @see JavaCore#DO_NOT_INSERT 1805     * @since 3.0 1806     */ 1807    public static final String FORMATTER_INSERT_SPACE_AFTER_SEMICOLON_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_semicolon_in_for"; //$NON-NLS-1$ 1808 /** 1809     * <pre> 1810     * FORMATTER / Option to insert a space after an unary operator 1811     * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_unary_operator" 1812     * - possible values: { INSERT, DO_NOT_INSERT } 1813     * - default: DO_NOT_INSERT 1814     * </pre> 1815     * @see JavaCore#INSERT 1816     * @see JavaCore#DO_NOT_INSERT 1817     * @since 3.0 1818     */ 1819    public static final String FORMATTER_INSERT_SPACE_AFTER_UNARY_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_unary_operator"; //$NON-NLS-1$ 1820 /** 1821     * <pre> 1822     * FORMATTER / Option to insert a space before and in wildcard 1823     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter" 1824     * - possible values: { INSERT, DO_NOT_INSERT } 1825     * - default: INSERT 1826     * </pre> 1827     * @see JavaCore#INSERT 1828     * @see JavaCore#DO_NOT_INSERT 1829     * @since 3.1 1830     */ 1831    public static final String FORMATTER_INSERT_SPACE_BEFORE_AND_IN_TYPE_PARAMETER = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_and_in_type_parameter"; //$NON-NLS-1$ 1832 /** 1833     * <pre> 1834     * FORMATTER / Option to insert a space before an assignment operator 1835     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator" 1836     * - possible values: { INSERT, DO_NOT_INSERT } 1837     * - default: INSERT 1838     * </pre> 1839     * @see JavaCore#INSERT 1840     * @see JavaCore#DO_NOT_INSERT 1841     * @since 3.0 1842     */ 1843    public static final String FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_assignment_operator"; //$NON-NLS-1$ 1844 /** 1845     * <pre> 1846     * FORMATTER / Option to insert a space before at in annotation type declaration 1847     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" 1848     * - possible values: { INSERT, DO_NOT_INSERT } 1849     * - default: INSERT 1850     * </pre> 1851     * @see JavaCore#INSERT 1852     * @see JavaCore#DO_NOT_INSERT 1853     * @since 3.1 1854     */ 1855    public static final String FORMATTER_INSERT_SPACE_BEFORE_AT_IN_ANNOTATION_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_at_in_annotation_type_declaration"; //$NON-NLS-1$ 1856 /** 1857     * <pre> 1858     * FORMATTER / Option to insert a space before an binary operator 1859     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_binary_operator" 1860     * - possible values: { INSERT, DO_NOT_INSERT } 1861     * - default: DO_NOT_INSERT 1862     * </pre> 1863     * @see JavaCore#INSERT 1864     * @see JavaCore#DO_NOT_INSERT 1865     * @since 3.0 1866     */ 1867    public static final String FORMATTER_INSERT_SPACE_BEFORE_BINARY_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_binary_operator"; //$NON-NLS-1$ 1868 /** 1869     * <pre> 1870     * FORMATTER / Option to insert a space before the closing angle bracket in parameterized type reference 1871     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference" 1872     * - possible values: { INSERT, DO_NOT_INSERT } 1873     * - default: DO_NOT_INSERT 1874     * </pre> 1875     * @see JavaCore#INSERT 1876     * @see JavaCore#DO_NOT_INSERT 1877     * @since 3.1 1878     */ 1879    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference"; //$NON-NLS-1$ 1880 /** 1881     * <pre> 1882     * FORMATTER / Option to insert a space before the closing angle bracket in type arguments 1883     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments" 1884     * - possible values: { INSERT, DO_NOT_INSERT } 1885     * - default: DO_NOT_INSERT 1886     * </pre> 1887     * @see JavaCore#INSERT 1888     * @see JavaCore#DO_NOT_INSERT 1889     * @since 3.1 1890     */ 1891    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_type_arguments"; //$NON-NLS-1$ 1892 /** 1893     * <pre> 1894     * FORMATTER / Option to insert a space before the closing angle bracket in type parameters 1895     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters" 1896     * - possible values: { INSERT, DO_NOT_INSERT } 1897     * - default: DO_NOT_INSERT 1898     * </pre> 1899     * @see JavaCore#INSERT 1900     * @see JavaCore#DO_NOT_INSERT 1901     * @since 3.1 1902     */ 1903    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_angle_bracket_in_type_parameters"; //$NON-NLS-1$ 1904 /** 1905     * <pre> 1906     * FORMATTER / Option to insert a space before the closing brace in an array initializer 1907     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" 1908     * - possible values: { INSERT, DO_NOT_INSERT } 1909     * - default: DO_NOT_INSERT 1910     * </pre> 1911     * @see JavaCore#INSERT 1912     * @see JavaCore#DO_NOT_INSERT 1913     * @since 3.0 1914     */ 1915    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACE_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_brace_in_array_initializer"; //$NON-NLS-1$ 1916 /** 1917     * <pre> 1918     * FORMATTER / Option to insert a space before the closing bracket in an array allocation expression 1919     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression" 1920     * - possible values: { INSERT, DO_NOT_INSERT } 1921     * - default: DO_NOT_INSERT 1922     * </pre> 1923     * @see JavaCore#INSERT 1924     * @see JavaCore#DO_NOT_INSERT 1925     * @since 3.0 1926     */ 1927    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_bracket_in_array_allocation_expression";//$NON-NLS-1$ 1928 /** 1929     * <pre> 1930     * FORMATTER / Option to insert a space before the closing bracket in an array reference 1931     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference" 1932     * - possible values: { INSERT, DO_NOT_INSERT } 1933     * - default: DO_NOT_INSERT 1934     * </pre> 1935     * @see JavaCore#INSERT 1936     * @see JavaCore#DO_NOT_INSERT 1937     * @since 3.0 1938     */ 1939    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_BRACKET_IN_ARRAY_REFERENCE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_bracket_in_array_reference";//$NON-NLS-1$ 1940 /** 1941     * <pre> 1942     * FORMATTER / Option to insert a space before the closing parenthesis in annotation 1943     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation" 1944     * - possible values: { INSERT, DO_NOT_INSERT } 1945     * - default: DO_NOT_INSERT 1946     * </pre> 1947     * @see JavaCore#INSERT 1948     * @see JavaCore#DO_NOT_INSERT 1949     * @since 3.1 1950     */ 1951    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_annotation"; //$NON-NLS-1$ 1952 /** 1953     * <pre> 1954     * FORMATTER / Option to insert a space before the closing parenthesis in a cast expression 1955     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast" 1956     * - possible values: { INSERT, DO_NOT_INSERT } 1957     * - default: DO_NOT_INSERT 1958     * </pre> 1959     * @see JavaCore#INSERT 1960     * @see JavaCore#DO_NOT_INSERT 1961     * @since 3.0 1962     */ 1963    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CAST = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_cast"; //$NON-NLS-1$ 1964 /** 1965     * <pre> 1966     * FORMATTER / Option to insert a space before the closing parenthesis in a catch 1967     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch" 1968     * - possible values: { INSERT, DO_NOT_INSERT } 1969     * - default: DO_NOT_INSERT 1970     * </pre> 1971     * @see JavaCore#INSERT 1972     * @see JavaCore#DO_NOT_INSERT 1973     * @since 3.0 1974     */ 1975    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CATCH = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_catch"; //$NON-NLS-1$ 1976 /** 1977     * <pre> 1978     * FORMATTER / Option to insert a space before the closing parenthesis in a constructor declaration 1979     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration" 1980     * - possible values: { INSERT, DO_NOT_INSERT } 1981     * - default: DO_NOT_INSERT 1982     * </pre> 1983     * @see JavaCore#INSERT 1984     * @see JavaCore#DO_NOT_INSERT 1985     * @since 3.0 1986     */ 1987    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_CONSTRUCTOR_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_constructor_declaration"; //$NON-NLS-1$ 1988 /** 1989     * <pre> 1990     * FORMATTER / Option to insert a space before the closing parenthesis in enum constant 1991     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant" 1992     * - possible values: { INSERT, DO_NOT_INSERT } 1993     * - default: DO_NOT_INSERT 1994     * </pre> 1995     * @see JavaCore#INSERT 1996     * @see JavaCore#DO_NOT_INSERT 1997     * @since 3.1 1998     */ 1999    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_enum_constant"; //$NON-NLS-1$ 2000 /** 2001     * <pre> 2002     * FORMATTER / Option to insert a space before the closing parenthesis in a for statement 2003     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for" 2004     * - possible values: { INSERT, DO_NOT_INSERT } 2005     * - default: DO_NOT_INSERT 2006     * </pre> 2007     * @see JavaCore#INSERT 2008     * @see JavaCore#DO_NOT_INSERT 2009     * @since 3.0 2010     */ 2011    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_for"; //$NON-NLS-1$ 2012 /** 2013     * <pre> 2014     * FORMATTER / Option to insert a space before the closing parenthesis in an if statement 2015     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if" 2016     * - possible values: { INSERT, DO_NOT_INSERT } 2017     * - default: DO_NOT_INSERT 2018     * </pre> 2019     * @see JavaCore#INSERT 2020     * @see JavaCore#DO_NOT_INSERT 2021     * @since 3.0 2022     */ 2023    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_IF = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_if"; //$NON-NLS-1$ 2024 /** 2025     * <pre> 2026     * FORMATTER / Option to insert a space before the closing parenthesis in a method declaration 2027     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" 2028     * - possible values: { INSERT, DO_NOT_INSERT } 2029     * - default: DO_NOT_INSERT 2030     * </pre> 2031     * @see JavaCore#INSERT 2032     * @see JavaCore#DO_NOT_INSERT 2033     * @since 3.0 2034     */ 2035    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_method_declaration"; //$NON-NLS-1$ 2036 /** 2037     * <pre> 2038     * FORMATTER / Option to insert a space before the closing parenthesis in a method invocation 2039     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" 2040     * - possible values: { INSERT, DO_NOT_INSERT } 2041     * - default: DO_NOT_INSERT 2042     * </pre> 2043     * @see JavaCore#INSERT 2044     * @see JavaCore#DO_NOT_INSERT 2045     * @since 3.0 2046     */ 2047    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_METHOD_INVOCATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_method_invocation"; //$NON-NLS-1$ 2048 /** 2049     * <pre> 2050     * FORMATTER / Option to insert a space before the closing parenthesis in a parenthesized expression 2051     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression" 2052     * - possible values: { INSERT, DO_NOT_INSERT } 2053     * - default: DO_NOT_INSERT 2054     * </pre> 2055     * @see JavaCore#INSERT 2056     * @see JavaCore#DO_NOT_INSERT 2057     * @since 3.0 2058     */ 2059    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_PARENTHESIZED_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_parenthesized_expression"; //$NON-NLS-1$ 2060 /** 2061     * <pre> 2062     * FORMATTER / Option to insert a space before the closing parenthesis in a switch statement 2063     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch" 2064     * - possible values: { INSERT, DO_NOT_INSERT } 2065     * - default: DO_NOT_INSERT 2066     * </pre> 2067     * @see JavaCore#INSERT 2068     * @see JavaCore#DO_NOT_INSERT 2069     * @since 3.0 2070     */ 2071    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SWITCH = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_switch"; //$NON-NLS-1$ 2072 /** 2073     * <pre> 2074     * FORMATTER / Option to insert a space before the closing parenthesis in a synchronized statement 2075     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized" 2076     * - possible values: { INSERT, DO_NOT_INSERT } 2077     * - default: DO_NOT_INSERT 2078     * </pre> 2079     * @see JavaCore#INSERT 2080     * @see JavaCore#DO_NOT_INSERT 2081     * @since 3.0 2082     */ 2083    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_SYNCHRONIZED = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_synchronized"; //$NON-NLS-1$ 2084 /** 2085     * <pre> 2086     * FORMATTER / Option to insert a space before the closing parenthesis in a while statement 2087     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while" 2088     * - possible values: { INSERT, DO_NOT_INSERT } 2089     * - default: DO_NOT_INSERT 2090     * </pre> 2091     * @see JavaCore#INSERT 2092     * @see JavaCore#DO_NOT_INSERT 2093     * @since 3.0 2094     */ 2095    public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_WHILE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_while"; //$NON-NLS-1$ 2096 /** 2097     * <pre> 2098     * FORMATTER / Option to insert a space before colon in an assert statement 2099     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert" 2100     * - possible values: { INSERT, DO_NOT_INSERT } 2101     * - default: INSERT 2102     * </pre> 2103     * @see JavaCore#INSERT 2104     * @see JavaCore#DO_NOT_INSERT 2105     * @since 3.0 2106     */ 2107    public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_ASSERT = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_assert"; //$NON-NLS-1$ 2108 /** 2109     * <pre> 2110     * FORMATTER / Option to insert a space before colon in a case statement 2111     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" 2112     * - possible values: { INSERT, DO_NOT_INSERT } 2113     * - default: INSERT 2114     * </pre> 2115     * @see JavaCore#INSERT 2116     * @see JavaCore#DO_NOT_INSERT 2117     * @since 3.0 2118     */ 2119    public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CASE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_case"; //$NON-NLS-1$ 2120 /** 2121     * <pre> 2122     * FORMATTER / Option to insert a space before colon in a conditional expression 2123     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" 2124     * - possible values: { INSERT, DO_NOT_INSERT } 2125     * - default: INSERT 2126     * </pre> 2127     * @see JavaCore#INSERT 2128     * @see JavaCore#DO_NOT_INSERT 2129     * @since 3.0 2130     */ 2131    public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CONDITIONAL = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_conditional"; //$NON-NLS-1$ 2132 /** 2133     * <pre> 2134     * FORMATTER / Option to insert a space before colon in a default statement 2135     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" 2136     * - possible values: { INSERT, DO_NOT_INSERT } 2137     * - default: INSERT 2138     * </pre> 2139     * @see JavaCore#INSERT 2140     * @see JavaCore#DO_NOT_INSERT 2141     * @since 3.0 2142     */ 2143    public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_DEFAULT = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_default"; //$NON-NLS-1$ 2144 /** 2145     * <pre> 2146     * FORMATTER / Option to insert a space before colon in a for statement 2147     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for" 2148     * - possible values: { INSERT, DO_NOT_INSERT } 2149     * - default: INSERT 2150     * </pre> 2151     * @see JavaCore#INSERT 2152     * @see JavaCore#DO_NOT_INSERT 2153     * @since 3.1 2154     */ 2155    public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_for"; //$NON-NLS-1$ 2156 /** 2157     * <pre> 2158     * FORMATTER / Option to insert a space before colon in a labeled statement 2159     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" 2160     * - possible values: { INSERT, DO_NOT_INSERT } 2161     * - default: INSERT 2162     * </pre> 2163     * @see JavaCore#INSERT 2164     * @see JavaCore#DO_NOT_INSERT 2165     * @since 3.0 2166     */ 2167    public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_LABELED_STATEMENT = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_labeled_statement"; //$NON-NLS-1$ 2168 /** 2169     * <pre> 2170     * FORMATTER / Option to insert a space before comma in an allocation expression 2171     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression" 2172     * - possible values: { INSERT, DO_NOT_INSERT } 2173     * - default: DO_NOT_INSERT 2174     * </pre> 2175     * @see JavaCore#INSERT 2176     * @see JavaCore#DO_NOT_INSERT 2177     * @since 3.0 2178     */ 2179    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ALLOCATION_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_allocation_expression"; //$NON-NLS-1$ 2180 /** 2181     * <pre> 2182     * FORMATTER / Option to insert a space before comma in annotation 2183     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation" 2184     * - possible values: { INSERT, DO_NOT_INSERT } 2185     * - default: DO_NOT_INSERT 2186     * </pre> 2187     * @see JavaCore#INSERT 2188     * @see JavaCore#DO_NOT_INSERT 2189     * @since 3.1 2190     */ 2191    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_annotation"; //$NON-NLS-1$ 2192 /** 2193     * <pre> 2194     * FORMATTER / Option to insert a space before comma in an array initializer 2195     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer" 2196     * - possible values: { INSERT, DO_NOT_INSERT } 2197     * - default: DO_NOT_INSERT 2198     * </pre> 2199     * @see JavaCore#INSERT 2200     * @see JavaCore#DO_NOT_INSERT 2201     * @since 3.0 2202     */ 2203    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_array_initializer"; //$NON-NLS-1$ 2204 /** 2205     * <pre> 2206     * FORMATTER / Option to insert a space before comma in the parameters of a constructor declaration 2207     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters" 2208     * - possible values: { INSERT, DO_NOT_INSERT } 2209     * - default: DO_NOT_INSERT 2210     * </pre> 2211     * @see JavaCore#INSERT 2212     * @see JavaCore#DO_NOT_INSERT 2213     * @since 3.0 2214     */ 2215    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_constructor_declaration_parameters"; //$NON-NLS-1$ 2216 /** 2217     * <pre> 2218     * FORMATTER / Option to insert a space before comma in the exception names of the throws clause of a constructor declaration 2219     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws" 2220     * - possible values: { INSERT, DO_NOT_INSERT } 2221     * - default: DO_NOT_INSERT 2222     * </pre> 2223     * @see JavaCore#INSERT 2224     * @see JavaCore#DO_NOT_INSERT 2225     * @since 3.0 2226     */ 2227    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_CONSTRUCTOR_DECLARATION_THROWS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_constructor_declaration_throws"; //$NON-NLS-1$ 2228 /** 2229     * <pre> 2230     * FORMATTER / Option to insert a space before comma in the arguments of enum constant 2231     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments" 2232     * - possible values: { INSERT, DO_NOT_INSERT } 2233     * - default: DO_NOT_INSERT 2234     * </pre> 2235     * @see JavaCore#INSERT 2236     * @see JavaCore#DO_NOT_INSERT 2237     * @since 3.1 2238     */ 2239    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_CONSTANT_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_enum_constant_arguments"; //$NON-NLS-1$ 2240 /** 2241     * <pre> 2242     * FORMATTER / Option to insert a space before comma in enum declarations 2243     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations" 2244     * - possible values: { INSERT, DO_NOT_INSERT } 2245     * - default: DO_NOT_INSERT 2246     * </pre> 2247     * @see JavaCore#INSERT 2248     * @see JavaCore#DO_NOT_INSERT 2249     * @since 3.1 2250     */ 2251    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ENUM_DECLARATIONS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_enum_declarations"; //$NON-NLS-1$ 2252 /** 2253     * <pre> 2254     * FORMATTER / Option to insert a space before comma in the arguments of an explicit constructor call 2255     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments" 2256     * - possible values: { INSERT, DO_NOT_INSERT } 2257     * - default: DO_NOT_INSERT 2258     * </pre> 2259     * @see JavaCore#INSERT 2260     * @see JavaCore#DO_NOT_INSERT 2261     * @since 3.0 2262     */ 2263    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_EXPLICIT_CONSTRUCTOR_CALL_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_explicitconstructorcall_arguments"; //$NON-NLS-1$ 2264 /** 2265     * <pre> 2266     * FORMATTER / Option to insert a space before comma in the increments of a for statement 2267     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments" 2268     * - possible values: { INSERT, DO_NOT_INSERT } 2269     * - default: DO_NOT_INSERT 2270     * </pre> 2271     * @see JavaCore#INSERT 2272     * @see JavaCore#DO_NOT_INSERT 2273     * @since 3.0 2274     */ 2275    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INCREMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_for_increments"; //$NON-NLS-1$ 2276 /** 2277     * <pre> 2278     * FORMATTER / Option to insert a space before comma in the initializations of a for statement 2279     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits" 2280     * - possible values: { INSERT, DO_NOT_INSERT } 2281     * - default: DO_NOT_INSERT 2282     * </pre> 2283     * @see JavaCore#INSERT 2284     * @see JavaCore#DO_NOT_INSERT 2285     * @since 3.0 2286     */ 2287    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_FOR_INITS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_for_inits"; //$NON-NLS-1$ 2288 /** 2289     * <pre> 2290     * FORMATTER / Option to insert a space before comma in the parameters of a method declaration 2291     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" 2292     * - possible values: { INSERT, DO_NOT_INSERT } 2293     * - default: DO_NOT_INSERT 2294     * </pre> 2295     * @see JavaCore#INSERT 2296     * @see JavaCore#DO_NOT_INSERT 2297     * @since 3.0 2298     */ 2299    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_declaration_parameters"; //$NON-NLS-1$ 2300 /** 2301     * <pre> 2302     * FORMATTER / Option to insert a space before comma in the exception names of the throws clause of a method declaration 2303     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws" 2304     * - possible values: { INSERT, DO_NOT_INSERT } 2305     * - default: DO_NOT_INSERT 2306     * </pre> 2307     * @see JavaCore#INSERT 2308     * @see JavaCore#DO_NOT_INSERT 2309     * @since 3.0 2310     */ 2311    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_DECLARATION_THROWS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_declaration_throws"; //$NON-NLS-1$ 2312 /** 2313     * <pre> 2314     * FORMATTER / Option to insert a space before comma in the arguments of a method invocation 2315     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" 2316     * - possible values: { INSERT, DO_NOT_INSERT } 2317     * - default: DO_NOT_INSERT 2318     * </pre> 2319     * @see JavaCore#INSERT 2320     * @see JavaCore#DO_NOT_INSERT 2321     * @since 3.0 2322     */ 2323    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_METHOD_INVOCATION_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_method_invocation_arguments"; //$NON-NLS-1$ 2324 /** 2325     * <pre> 2326     * FORMATTER / Option to insert a space before comma in a multiple field declaration 2327     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations" 2328     * - possible values: { INSERT, DO_NOT_INSERT } 2329     * - default: DO_NOT_INSERT 2330     * </pre> 2331     * @see JavaCore#INSERT 2332     * @see JavaCore#DO_NOT_INSERT 2333     * @since 3.0 2334     */ 2335    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_FIELD_DECLARATIONS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_multiple_field_declarations"; //$NON-NLS-1$ 2336 /** 2337     * <pre> 2338     * FORMATTER / Option to insert a space before comma in a multiple local declaration 2339     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations" 2340     * - possible values: { INSERT, DO_NOT_INSERT } 2341     * - default: DO_NOT_INSERT 2342     * </pre> 2343     * @see JavaCore#INSERT 2344     * @see JavaCore#DO_NOT_INSERT 2345     * @since 3.0 2346     */ 2347    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_MULTIPLE_LOCAL_DECLARATIONS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_multiple_local_declarations"; //$NON-NLS-1$ 2348 /** 2349     * <pre> 2350     * FORMATTER / Option to insert a space before comma in parameterized type reference 2351     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference" 2352     * - possible values: { INSERT, DO_NOT_INSERT } 2353     * - default: DO_NOT_INSERT 2354     * </pre> 2355     * @see JavaCore#INSERT 2356     * @see JavaCore#DO_NOT_INSERT 2357     * @since 3.1 2358     */ 2359    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_PARAMETERIZED_TYPE_REFERENCE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_parameterized_type_reference"; //$NON-NLS-1$ 2360 /** 2361     * <pre> 2362     * FORMATTER / Option to insert a space before comma in the superinterfaces names in a type header 2363     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces" 2364     * - possible values: { INSERT, DO_NOT_INSERT } 2365     * - default: DO_NOT_INSERT 2366     * </pre> 2367     * @see JavaCore#INSERT 2368     * @see JavaCore#DO_NOT_INSERT 2369     * @since 3.0 2370     */ 2371    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_SUPERINTERFACES = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_superinterfaces"; //$NON-NLS-1$ 2372 /** 2373     * <pre> 2374     * FORMATTER / Option to insert a space before comma in type arguments 2375     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments" 2376     * - possible values: { INSERT, DO_NOT_INSERT } 2377     * - default: DO_NOT_INSERT 2378     * </pre> 2379     * @see JavaCore#INSERT 2380     * @see JavaCore#DO_NOT_INSERT 2381     * @since 3.1 2382     */ 2383    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_type_arguments"; //$NON-NLS-1$ 2384 /** 2385     * <pre> 2386     * FORMATTER / Option to insert a space before comma in type parameters 2387     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters" 2388     * - possible values: { INSERT, DO_NOT_INSERT } 2389     * - default: DO_NOT_INSERT 2390     * </pre> 2391     * @see JavaCore#INSERT 2392     * @see JavaCore#DO_NOT_INSERT 2393     * @since 3.1 2394     */ 2395    public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_TYPE_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_type_parameters"; //$NON-NLS-1$ 2396 /** 2397     * <pre> 2398     * FORMATTER / Option to insert a space before ellipsis 2399     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_ellipsis" 2400     * - possible values: { INSERT, DO_NOT_INSERT } 2401     * - default: DO_NOT_INSERT 2402     * </pre> 2403     * @see JavaCore#INSERT 2404     * @see JavaCore#DO_NOT_INSERT 2405     * @since 3.1 2406     */ 2407    public static final String FORMATTER_INSERT_SPACE_BEFORE_ELLIPSIS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_ellipsis"; //$NON-NLS-1$ 2408 /** 2409     * <pre> 2410     * FORMATTER / Option to insert a space before the opening angle bracket in parameterized type reference 2411     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference" 2412     * - possible values: { INSERT, DO_NOT_INSERT } 2413     * - default: DO_NOT_INSERT 2414     * </pre> 2415     * @see JavaCore#INSERT 2416     * @see JavaCore#DO_NOT_INSERT 2417     * @since 3.1 2418     */ 2419    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_PARAMETERIZED_TYPE_REFERENCE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference"; //$NON-NLS-1$ 2420 /** 2421     * <pre> 2422     * FORMATTER / Option to insert a space before the opening angle bracket in type arguments 2423     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments" 2424     * - possible values: { INSERT, DO_NOT_INSERT } 2425     * - default: DO_NOT_INSERT 2426     * </pre> 2427     * @see JavaCore#INSERT 2428     * @see JavaCore#DO_NOT_INSERT 2429     * @since 3.1 2430     */ 2431    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_type_arguments"; //$NON-NLS-1$ 2432 /** 2433     * <pre> 2434     * FORMATTER / Option to insert a space before the opening angle bracket in type parameters 2435     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters" 2436     * - possible values: { INSERT, DO_NOT_INSERT } 2437     * - default: DO_NOT_INSERT 2438     * </pre> 2439     * @see JavaCore#INSERT 2440     * @see JavaCore#DO_NOT_INSERT 2441     * @since 3.1 2442     */ 2443    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_ANGLE_BRACKET_IN_TYPE_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_angle_bracket_in_type_parameters"; //$NON-NLS-1$ 2444 /** 2445     * <pre> 2446     * FORMATTER / Option to insert a space before the opening brace in an annotation type declaration 2447     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration" 2448     * - possible values: { INSERT, DO_NOT_INSERT } 2449     * - default: INSERT 2450     * </pre> 2451     * @see JavaCore#INSERT 2452     * @see JavaCore#DO_NOT_INSERT 2453     * @since 3.1 2454     */ 2455    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ANNOTATION_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_annotation_type_declaration"; //$NON-NLS-1$ 2456 /** 2457     * <pre> 2458     * FORMATTER / Option to insert a space before the opening brace in an anonymous type declaration 2459     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration" 2460     * - possible values: { INSERT, DO_NOT_INSERT } 2461     * - default: INSERT 2462     * </pre> 2463     * @see JavaCore#INSERT 2464     * @see JavaCore#DO_NOT_INSERT 2465     * @since 3.0 2466     */ 2467    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ANONYMOUS_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_anonymous_type_declaration"; //$NON-NLS-1$ 2468 /** 2469     * <pre> 2470     * FORMATTER / Option to insert a space before the opening brace in an array initializer 2471     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" 2472     * - possible values: { INSERT, DO_NOT_INSERT } 2473     * - default: DO_NOT_INSERT 2474     * </pre> 2475     * @see JavaCore#INSERT 2476     * @see JavaCore#DO_NOT_INSERT 2477     * @since 3.0 2478     */ 2479    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_array_initializer"; //$NON-NLS-1$ 2480 /** 2481     * <pre> 2482     * FORMATTER / Option to insert a space before the opening brace in a block 2483     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" 2484     * - possible values: { INSERT, DO_NOT_INSERT } 2485     * - default: INSERT 2486     * </pre> 2487     * @see JavaCore#INSERT 2488     * @see JavaCore#DO_NOT_INSERT 2489     * @since 3.0 2490     */ 2491    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_BLOCK = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_block"; //$NON-NLS-1$ 2492 /** 2493     * <pre> 2494     * FORMATTER / Option to insert a space before the opening brace in a constructor declaration 2495     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration" 2496     * - possible values: { INSERT, DO_NOT_INSERT } 2497     * - default: INSERT 2498     * </pre> 2499     * @see JavaCore#INSERT 2500     * @see JavaCore#DO_NOT_INSERT 2501     * @since 3.0 2502     */ 2503    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_CONSTRUCTOR_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_constructor_declaration"; //$NON-NLS-1$ 2504 /** 2505     * <pre> 2506     * FORMATTER / Option to insert a space before the opening brace in an enum constant 2507     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant" 2508     * - possible values: { INSERT, DO_NOT_INSERT } 2509     * - default: INSERT 2510     * </pre> 2511     * @see JavaCore#INSERT 2512     * @see JavaCore#DO_NOT_INSERT 2513     * @since 3.1 2514     */ 2515    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_enum_constant"; //$NON-NLS-1$ 2516 /** 2517     * <pre> 2518     * FORMATTER / Option to insert a space before the opening brace in an enum declaration 2519     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" 2520     * - possible values: { INSERT, DO_NOT_INSERT } 2521     * - default: INSERT 2522     * </pre> 2523     * @see JavaCore#INSERT 2524     * @see JavaCore#DO_NOT_INSERT 2525     * @since 3.1 2526     */ 2527    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_ENUM_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_enum_declaration"; //$NON-NLS-1$ 2528 /** 2529     * <pre> 2530     * FORMATTER / Option to insert a space before the opening brace in a method declaration 2531     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" 2532     * - possible values: { INSERT, DO_NOT_INSERT } 2533     * - default: INSERT 2534     * </pre> 2535     * @see JavaCore#INSERT 2536     * @see JavaCore#DO_NOT_INSERT 2537     * @since 3.0 2538     */ 2539    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_method_declaration"; //$NON-NLS-1$ 2540 /** 2541     * <pre> 2542     * FORMATTER / Option to insert a space before the opening brace in a switch statement 2543     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch" 2544     * - possible values: { INSERT, DO_NOT_INSERT } 2545     * - default: INSERT 2546     * </pre> 2547     * @see JavaCore#INSERT 2548     * @see JavaCore#DO_NOT_INSERT 2549     * @since 3.0 2550     */ 2551    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_SWITCH = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_switch"; //$NON-NLS-1$ 2552 /** 2553     * <pre> 2554     * FORMATTER / Option to insert a space before the opening brace in a type declaration 2555     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" 2556     * - possible values: { INSERT, DO_NOT_INSERT } 2557     * - default: INSERT 2558     * </pre> 2559     * @see JavaCore#INSERT 2560     * @see JavaCore#DO_NOT_INSERT 2561     * @since 3.0 2562     */ 2563    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_type_declaration"; //$NON-NLS-1$ 2564 /** 2565     * <pre> 2566     * FORMATTER / Option to insert a space before the opening bracket in an array allocation expression 2567     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression" 2568     * - possible values: { INSERT, DO_NOT_INSERT } 2569     * - default: DO_NOT_INSERT 2570     * </pre> 2571     * @see JavaCore#INSERT 2572     * @see JavaCore#DO_NOT_INSERT 2573     * @since 3.0 2574     */ 2575    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_ALLOCATION_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_allocation_expression";//$NON-NLS-1$ 2576 /** 2577     * <pre> 2578     * FORMATTER / Option to insert a space before the opening bracket in an array reference 2579     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference" 2580     * - possible values: { INSERT, DO_NOT_INSERT } 2581     * - default: DO_NOT_INSERT 2582     * </pre> 2583     * @see JavaCore#INSERT 2584     * @see JavaCore#DO_NOT_INSERT 2585     * @since 3.0 2586     */ 2587    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_REFERENCE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_reference";//$NON-NLS-1$ 2588 /** 2589     * <pre> 2590     * FORMATTER / Option to insert a space before the opening bracket in an array type reference 2591     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference" 2592     * - possible values: { INSERT, DO_NOT_INSERT } 2593     * - default: DO_NOT_INSERT 2594     * </pre> 2595     * @see JavaCore#INSERT 2596     * @see JavaCore#DO_NOT_INSERT 2597     * @since 3.0 2598     */ 2599    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACKET_IN_ARRAY_TYPE_REFERENCE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_bracket_in_array_type_reference"; //$NON-NLS-1$ 2600 /** 2601     * <pre> 2602     * FORMATTER / Option to insert a space before the opening parenthesis in annotation 2603     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation" 2604     * - possible values: { INSERT, DO_NOT_INSERT } 2605     * - default: DO_NOT_INSERT 2606     * </pre> 2607     * @see JavaCore#INSERT 2608     * @see JavaCore#DO_NOT_INSERT 2609     * @since 3.1 2610     */ 2611    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_annotation"; //$NON-NLS-1$ 2612 /** 2613     * <pre> 2614     * FORMATTER / Option to insert a space before the opening parenthesis in annotation type member declaration 2615     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration" 2616     * - possible values: { INSERT, DO_NOT_INSERT } 2617     * - default: DO_NOT_INSERT 2618     * </pre> 2619     * @see JavaCore#INSERT 2620     * @see JavaCore#DO_NOT_INSERT 2621     * @since 3.1 2622     */ 2623    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ANNOTATION_TYPE_MEMBER_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration"; //$NON-NLS-1$ 2624 /** 2625     * <pre> 2626     * FORMATTER / Option to insert a space before the opening parenthesis in a catch 2627     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch" 2628     * - possible values: { INSERT, DO_NOT_INSERT } 2629     * - default: INSERT 2630     * </pre> 2631     * @see JavaCore#INSERT 2632     * @see JavaCore#DO_NOT_INSERT 2633     * @since 3.0 2634     */ 2635    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CATCH = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_catch"; //$NON-NLS-1$ 2636 /** 2637     * <pre> 2638     * FORMATTER / Option to insert a space before the opening parenthesis in a constructor declaration 2639     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration" 2640     * - possible values: { INSERT, DO_NOT_INSERT } 2641     * - default: DO_NOT_INSERT 2642     * </pre> 2643     * @see JavaCore#INSERT 2644     * @see JavaCore#DO_NOT_INSERT 2645     * @since 3.0 2646     */ 2647    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_CONSTRUCTOR_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_constructor_declaration"; //$NON-NLS-1$ 2648 /** 2649     * <pre> 2650     * FORMATTER / Option to insert a space before the opening parenthesis in enum constant 2651     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant" 2652     * - possible values: { INSERT, DO_NOT_INSERT } 2653     * - default: DO_NOT_INSERT 2654     * </pre> 2655     * @see JavaCore#INSERT 2656     * @see JavaCore#DO_NOT_INSERT 2657     * @since 3.1 2658     */ 2659    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_enum_constant"; //$NON-NLS-1$ 2660 /** 2661     * <pre> 2662     * FORMATTER / Option to insert a space before the opening parenthesis in a for statement 2663     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for" 2664     * - possible values: { INSERT, DO_NOT_INSERT } 2665     * - default: INSERT 2666     * </pre> 2667     * @see JavaCore#INSERT 2668     * @see JavaCore#DO_NOT_INSERT 2669     * @since 3.0 2670     */ 2671    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_for"; //$NON-NLS-1$ 2672 /** 2673     * <pre> 2674     * FORMATTER / Option to insert a space before the opening parenthesis in an if statement 2675     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if" 2676     * - possible values: { INSERT, DO_NOT_INSERT } 2677     * - default: INSERT 2678     * </pre> 2679     * @see JavaCore#INSERT 2680     * @see JavaCore#DO_NOT_INSERT 2681     * @since 3.0 2682     */ 2683    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_IF = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_if"; //$NON-NLS-1$ 2684 /** 2685     * <pre> 2686     * FORMATTER / Option to insert a space before the opening parenthesis in a method declaration 2687     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" 2688     * - possible values: { INSERT, DO_NOT_INSERT } 2689     * - default: DO_NOT_INSERT 2690     * </pre> 2691     * @see JavaCore#INSERT 2692     * @see JavaCore#DO_NOT_INSERT 2693     * @since 3.0 2694     */ 2695    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_method_declaration"; //$NON-NLS-1$ 2696 /** 2697     * <pre> 2698     * FORMATTER / Option to insert a space before the opening parenthesis in a method invocation 2699     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" 2700     * - possible values: { INSERT, DO_NOT_INSERT } 2701     * - default: DO_NOT_INSERT 2702     * </pre> 2703     * @see JavaCore#INSERT 2704     * @see JavaCore#DO_NOT_INSERT 2705     * @since 3.0 2706     */ 2707    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_METHOD_INVOCATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_method_invocation"; //$NON-NLS-1$ 2708 /** 2709     * <pre> 2710     * FORMATTER / Option to insert a space before the opening parenthesis in a parenthesized expression 2711     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression" 2712     * - possible values: { INSERT, DO_NOT_INSERT } 2713     * - default: DO_NOT_INSERT 2714     * </pre> 2715     * @see JavaCore#INSERT 2716     * @see JavaCore#DO_NOT_INSERT 2717     * @since 3.0 2718     */ 2719    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_PARENTHESIZED_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_parenthesized_expression"; //$NON-NLS-1$ 2720 /** 2721     * <pre> 2722     * FORMATTER / Option to insert a space before the opening parenthesis in a switch statement 2723     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch" 2724     * - possible values: { INSERT, DO_NOT_INSERT } 2725     * - default: INSERT 2726     * </pre> 2727     * @see JavaCore#INSERT 2728     * @see JavaCore#DO_NOT_INSERT 2729     * @since 3.0 2730     */ 2731    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SWITCH = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_switch"; //$NON-NLS-1$ 2732 /** 2733     * <pre> 2734     * FORMATTER / Option to insert a space before the opening parenthesis in a synchronized statement 2735     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized" 2736     * - possible values: { INSERT, DO_NOT_INSERT } 2737     * - default: INSERT 2738     * </pre> 2739     * @see JavaCore#INSERT 2740     * @see JavaCore#DO_NOT_INSERT 2741     * @since 3.0 2742     */ 2743    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_SYNCHRONIZED = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_synchronized"; //$NON-NLS-1$ 2744 /** 2745     * <pre> 2746     * FORMATTER / Option to insert a space before the opening parenthesis in a while statement 2747     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while" 2748     * - possible values: { INSERT, DO_NOT_INSERT } 2749     * - default: INSERT 2750     * </pre> 2751     * @see JavaCore#INSERT 2752     * @see JavaCore#DO_NOT_INSERT 2753     * @since 3.0 2754     */ 2755    public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_WHILE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_while"; //$NON-NLS-1$ 2756 /** 2757     * <pre> 2758     * FORMATTER / Option to insert a space before parenthesized expression in return statement 2759     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" 2760     * - possible values: { INSERT, DO_NOT_INSERT } 2761     * - default: INSERT 2762     * </pre> 2763     * 2764     * @see JavaCore#INSERT 2765     * @see JavaCore#DO_NOT_INSERT 2766     * @since 3.2 2767     */ 2768    public static final String FORMATTER_INSERT_SPACE_BEFORE_PARENTHESIZED_EXPRESSION_IN_RETURN = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_parenthesized_expression_in_return"; //$NON-NLS-1$ 2769 /** 2770     * <pre> 2771     * FORMATTER / Option to insert a space before parenthesized expression in throw statement 2772     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw" 2773     * - possible values: { INSERT, DO_NOT_INSERT } 2774     * - default: INSERT 2775     * </pre> 2776     * 2777     * @see JavaCore#INSERT 2778     * @see JavaCore#DO_NOT_INSERT 2779     * @since 3.3 2780     */ 2781    public static final String FORMATTER_INSERT_SPACE_BEFORE_PARENTHESIZED_EXPRESSION_IN_THROW = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_parenthesized_expression_in_throw"; //$NON-NLS-1$ 2782 /** 2783     * <pre> 2784     * FORMATTER / Option to insert a space before a postfix operator 2785     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator" 2786     * - possible values: { INSERT, DO_NOT_INSERT } 2787     * - default: DO_NOT_INSERT 2788     * </pre> 2789     * @see JavaCore#INSERT 2790     * @see JavaCore#DO_NOT_INSERT 2791     * @since 3.0 2792     */ 2793    public static final String FORMATTER_INSERT_SPACE_BEFORE_POSTFIX_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_postfix_operator"; //$NON-NLS-1$ 2794 /** 2795     * <pre> 2796     * FORMATTER / Option to insert a space before a prefix operator 2797     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator" 2798     * - possible values: { INSERT, DO_NOT_INSERT } 2799     * - default: DO_NOT_INSERT 2800     * </pre> 2801     * @see JavaCore#INSERT 2802     * @see JavaCore#DO_NOT_INSERT 2803     * @since 3.0 2804     */ 2805    public static final String FORMATTER_INSERT_SPACE_BEFORE_PREFIX_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_prefix_operator"; //$NON-NLS-1$ 2806 /** 2807     * <pre> 2808     * FORMATTER / Option to insert a space before question mark in a conditional expression 2809     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional" 2810     * - possible values: { INSERT, DO_NOT_INSERT } 2811     * - default: INSERT 2812     * </pre> 2813     * @see JavaCore#INSERT 2814     * @see JavaCore#DO_NOT_INSERT 2815     * @since 3.0 2816     */ 2817    public static final String FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_CONDITIONAL = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_question_in_conditional"; //$NON-NLS-1$ 2818 /** 2819     * <pre> 2820     * FORMATTER / Option to insert a space before question mark in a wildcard 2821     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard" 2822     * - possible values: { INSERT, DO_NOT_INSERT } 2823     * - default: DO_NOT_INSERT 2824     * </pre> 2825     * @see JavaCore#INSERT 2826     * @see JavaCore#DO_NOT_INSERT 2827     * @since 3.1 2828     */ 2829    public static final String FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_WILDCARD = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_question_in_wildcard"; //$NON-NLS-1$ 2830 /** 2831     * <pre> 2832     * FORMATTER / Option to insert a space before semicolon 2833     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_semicolon" 2834     * - possible values: { INSERT, DO_NOT_INSERT } 2835     * - default: DO_NOT_INSERT 2836     * </pre> 2837     * @see JavaCore#INSERT 2838     * @see JavaCore#DO_NOT_INSERT 2839     * @since 3.0 2840     */ 2841    public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_semicolon"; //$NON-NLS-1$ 2842 /** 2843     * <pre> 2844     * FORMATTER / Option to insert a space before semicolon in for statement 2845     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for" 2846     * - possible values: { INSERT, DO_NOT_INSERT } 2847     * - default: DO_NOT_INSERT 2848     * </pre> 2849     * @see JavaCore#INSERT 2850     * @see JavaCore#DO_NOT_INSERT 2851     * @since 3.0 2852     */ 2853    public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_semicolon_in_for"; //$NON-NLS-1$ 2854 /** 2855     * <pre> 2856     * FORMATTER / Option to insert a space before unary operator 2857     * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_unary_operator" 2858     * - possible values: { INSERT, DO_NOT_INSERT } 2859     * - default: DO_NOT_INSERT 2860     * </pre> 2861     * @see JavaCore#INSERT 2862     * @see JavaCore#DO_NOT_INSERT 2863     * @since 3.0 2864     */ 2865    public static final String FORMATTER_INSERT_SPACE_BEFORE_UNARY_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_unary_operator"; //$NON-NLS-1$ 2866 2867    /** 2868     * <pre> 2869     * FORMATTER / Option to insert a space between brackets in an array type reference 2870     * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference" 2871     * - possible values: { INSERT, DO_NOT_INSERT } 2872     * - default: DO_NOT_INSERT 2873     * </pre> 2874     * @see JavaCore#INSERT 2875     * @see JavaCore#DO_NOT_INSERT 2876     * @since 3.0 2877     */ 2878    public static final String FORMATTER_INSERT_SPACE_BETWEEN_BRACKETS_IN_ARRAY_TYPE_REFERENCE = JavaCore.PLUGIN_ID + ".formatter.insert_space_between_brackets_in_array_type_reference"; //$NON-NLS-1$ 2879 /** 2880     * <pre> 2881     * FORMATTER / Option to insert a space between empty braces in an array initializer 2882     * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" 2883     * - possible values: { INSERT, DO_NOT_INSERT } 2884     * - default: DO_NOT_INSERT 2885     * </pre> 2886     * @see JavaCore#INSERT 2887     * @see JavaCore#DO_NOT_INSERT 2888     * @since 3.0 2889     */ 2890    public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACES_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.insert_space_between_empty_braces_in_array_initializer"; //$NON-NLS-1$ 2891 /** 2892     * <pre> 2893     * FORMATTER / Option to insert a space between empty brackets in an array allocation expression 2894     * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression" 2895     * - possible values: { INSERT, DO_NOT_INSERT } 2896     * - default: DO_NOT_INSERT 2897     * </pre> 2898     * @see JavaCore#INSERT 2899     * @see JavaCore#DO_NOT_INSERT 2900     * @since 3.0 2901     */ 2902    public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_BRACKETS_IN_ARRAY_ALLOCATION_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.insert_space_between_empty_brackets_in_array_allocation_expression"; //$NON-NLS-1$ 2903 /** 2904     * <pre> 2905     * FORMATTER / Option to insert a space between empty parenthesis in an annotation type member declaration 2906     * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration" 2907     * - possible values: { INSERT, DO_NOT_INSERT } 2908     * - default: DO_NOT_INSERT 2909     * </pre> 2910     * @see JavaCore#INSERT 2911     * @see JavaCore#DO_NOT_INSERT 2912     * @since 3.1 2913     */ 2914    public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_ANNOTATION_TYPE_MEMBER_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration"; //$NON-NLS-1$ 2915 /** 2916     * <pre> 2917     * FORMATTER / Option to insert a space between empty parenthesis in a constructor declaration 2918     * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration" 2919     * - possible values: { INSERT, DO_NOT_INSERT } 2920     * - default: DO_NOT_INSERT 2921     * </pre> 2922     * @see JavaCore#INSERT 2923     * @see JavaCore#DO_NOT_INSERT 2924     * @since 3.0 2925     */ 2926    public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_CONSTRUCTOR_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_constructor_declaration"; //$NON-NLS-1$ 2927 /** 2928     * <pre> 2929     * FORMATTER / Option to insert a space between empty parenthesis in enum constant 2930     * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant" 2931     * - possible values: { INSERT, DO_NOT_INSERT } 2932     * - default: DO_NOT_INSERT 2933     * </pre> 2934     * @see JavaCore#INSERT 2935     * @see JavaCore#DO_NOT_INSERT 2936     * @since 3.1 2937     */ 2938    public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_enum_constant"; //$NON-NLS-1$ 2939 /** 2940     * <pre> 2941     * FORMATTER / Option to insert a space between empty parenthesis in a method declaration 2942     * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" 2943     * - possible values: { INSERT, DO_NOT_INSERT } 2944     * - default: DO_NOT_INSERT 2945     * </pre> 2946     * @see JavaCore#INSERT 2947     * @see JavaCore#DO_NOT_INSERT 2948     * @since 3.0 2949     */ 2950    public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_method_declaration"; //$NON-NLS-1$ 2951 /** 2952     * <pre> 2953     * FORMATTER / Option to insert a space between empty parenthesis in a method invocation 2954     * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation" 2955     * - possible values: { INSERT, DO_NOT_INSERT } 2956     * - default: DO_NOT_INSERT 2957     * </pre> 2958     * @see JavaCore#INSERT 2959     * @see JavaCore#DO_NOT_INSERT 2960     * @since 3.0 2961     */ 2962    public static final String FORMATTER_INSERT_SPACE_BETWEEN_EMPTY_PARENS_IN_METHOD_INVOCATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_between_empty_parens_in_method_invocation"; //$NON-NLS-1$ 2963 /** 2964     * <pre> 2965     * FORMATTER / Option to keep else statement on the same line 2966     * - option id: "org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line" 2967     * - possible values: { TRUE, FALSE } 2968     * - default: FALSE 2969     * </pre> 2970     * @see #TRUE 2971     * @see #FALSE 2972     * @since 3.0 2973     */ 2974    public static final String FORMATTER_KEEP_ELSE_STATEMENT_ON_SAME_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_else_statement_on_same_line"; //$NON-NLS-1$ 2975 /** 2976     * <pre> 2977     * FORMATTER / Option to keep empty array initializer one one line 2978     * - option id: "org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line" 2979     * - possible values: { TRUE, FALSE } 2980     * - default: FALSE 2981     * </pre> 2982     * @see #TRUE 2983     * @see #FALSE 2984     * @since 3.0 2985     */ 2986    public static final String FORMATTER_KEEP_EMPTY_ARRAY_INITIALIZER_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_empty_array_initializer_on_one_line"; //$NON-NLS-1$ 2987 /** 2988     * <pre> 2989     * FORMATTER / Option to keep guardian clause on one line 2990     * - option id: "org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line" 2991     * - possible values: { TRUE, FALSE } 2992     * - default: FALSE 2993     * </pre> 2994     * @see #TRUE 2995     * @see #FALSE 2996     * @since 3.0 2997     */ 2998    public static final String FORMATTER_KEEP_GUARDIAN_CLAUSE_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.format_guardian_clause_on_one_line"; //$NON-NLS-1$ 2999 /** 3000     * <pre> 3001     * FORMATTER / Option to keep simple if statement on the one line 3002     * - option id: "org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line" 3003     * - possible values: { TRUE, FALSE } 3004     * - default: FALSE 3005     * </pre> 3006     * @see #TRUE 3007     * @see #FALSE 3008     * @since 3.0 3009     */ 3010    public static final String FORMATTER_KEEP_SIMPLE_IF_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_imple_if_on_one_line"; //$NON-NLS-1$ 3011 /** 3012     * <pre> 3013     * FORMATTER / Option to keep then statement on the same line 3014     * - option id: "org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line" 3015     * - possible values: { TRUE, FALSE } 3016     * - default: FALSE 3017     * </pre> 3018     * @see #TRUE 3019     * @see #FALSE 3020     * @since 3.0 3021     */ 3022    public static final String FORMATTER_KEEP_THEN_STATEMENT_ON_SAME_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_then_statement_on_same_line";//$NON-NLS-1$ 3023 3024    /** 3025     * <pre> 3026     * FORMATTER / Option to specify the length of the page. Beyond this length, the formatter will try to split the code 3027     * - option id: "org.eclipse.jdt.core.formatter.lineSplit" 3028     * - possible values: "&lt;n&gt;", where n is zero or a positive integer 3029     * - default: "80" 3030     * </pre> 3031     * @since 3.0 3032     */ 3033    public static final String FORMATTER_LINE_SPLIT = JavaCore.PLUGIN_ID + ".formatter.lineSplit"; //$NON-NLS-1$ 3034 /** 3035     * <pre> 3036     * FORMATTER / Option to indent block comments that start on the first column 3037     * - option id: "org.eclipse.jdt.core.formatter.formatter.never_indent_block_comments_on_first_column" 3038     * - possible values: { TRUE, FALSE } 3039     * - default: FALSE 3040     * </pre> 3041     * Note that this option is ignored if the formatter is created with the mode {@link ToolFactory#M_FORMAT_NEW}. 3042     * @see #TRUE 3043     * @see #FALSE 3044     * @see ToolFactory#createCodeFormatter(Map, int) 3045     * @since 3.3 3046     */ 3047    public static final String FORMATTER_NEVER_INDENT_BLOCK_COMMENTS_ON_FIRST_COLUMN = JavaCore.PLUGIN_ID + ".formatter.never_indent_block_comments_on_first_column"; //$NON-NLS-1$ 3048 /** 3049     * <pre> 3050     * FORMATTER / Option to indent line comments that start on the first column 3051     * - option id: "org.eclipse.jdt.core.formatter.formatter.never_indent_line_comments_on_first_column" 3052     * - possible values: { TRUE, FALSE } 3053     * - default: FALSE 3054     * </pre> 3055     * Note that this option is ignored if the formatter is created with the mode {@link ToolFactory#M_FORMAT_NEW}. 3056     * @see #TRUE 3057     * @see #FALSE 3058     * @see ToolFactory#createCodeFormatter(Map, int) 3059     * @since 3.3 3060     */ 3061    public static final String FORMATTER_NEVER_INDENT_LINE_COMMENTS_ON_FIRST_COLUMN = JavaCore.PLUGIN_ID + ".formatter.never_indent_line_comments_on_first_column"; //$NON-NLS-1$ 3062 /** 3063     * <pre> 3064     * FORMATTER / Option to specify the number of empty lines to preserve 3065     * - option id: "org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve" 3066     * - possible values: "&lt;n&gt;", where n is zero or a positive integer 3067     * - default: "0" 3068     * </pre> 3069     * @since 3.0 3070     */ 3071    public static final String FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE = JavaCore.PLUGIN_ID + ".formatter.number_of_empty_lines_to_preserve"; //$NON-NLS-1$ 3072 /** 3073     * <pre> 3074     * FORMATTER / Option to specify whether or not empty statement should be on a new line 3075     * - option id: "org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line" 3076     * - possible values: { TRUE, FALSE } 3077     * - default: FALSE 3078     * </pre> 3079     * @see #TRUE 3080     * @see #FALSE 3081     * @since 3.0 3082     */ 3083    public static final String FORMATTER_PUT_EMPTY_STATEMENT_ON_NEW_LINE = JavaCore.PLUGIN_ID + ".formatter.put_empty_statement_on_new_line"; //$NON-NLS-1$ 3084 /** 3085     * <pre> 3086     * FORMATTER / Option to specify the tabulation size 3087     * - option id: "org.eclipse.jdt.core.formatter.tabulation.char" 3088     * - possible values: { TAB, SPACE, MIXED } 3089     * - default: TAB 3090     * </pre> 3091     * More values may be added in the future. 3092     * 3093     * @see JavaCore#TAB 3094     * @see JavaCore#SPACE 3095     * @see #MIXED 3096     * @since 3.0 3097     */ 3098    public static final String FORMATTER_TAB_CHAR = JavaCore.PLUGIN_ID + ".formatter.tabulation.char"; //$NON-NLS-1$ 3099 /** 3100     * <pre> 3101     * FORMATTER / Option to specify the equivalent number of spaces that represents one tabulation 3102     * - option id: "org.eclipse.jdt.core.formatter.tabulation.size" 3103     * - possible values: "&lt;n&gt;", where n is zero or a positive integer 3104     * - default: "4" 3105     * </pre> 3106     * @since 3.0 3107     */ 3108    public static final String FORMATTER_TAB_SIZE = JavaCore.PLUGIN_ID + ".formatter.tabulation.size"; //$NON-NLS-1$ 3109 3110    /** 3111     * <pre> 3112     * FORMATTER / Option to use tabulations only for leading indentations 3113     * - option id: "org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations" 3114     * - possible values: { TRUE, FALSE } 3115     * - default: FALSE 3116     * </pre> 3117     * @see #TRUE 3118     * @see #FALSE 3119     * @since 3.1 3120     */ 3121    public static final String FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS = JavaCore.PLUGIN_ID + ".formatter.use_tabs_only_for_leading_indentations"; //$NON-NLS-1$ 3122 /** 3123     * <pre> 3124     * FORMATTER / Option to wrap before the binary operator 3125     * - option id: "org.eclipse.jdt.core.formatter.wrap_before_binary_operator" 3126     * - possible values: { TRUE, FALSE } 3127     * - default: TRUE 3128     * </pre> 3129     * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION} is set. 3130     * @see #TRUE 3131     * @see #FALSE 3132     * @since 3.3 3133     */ 3134    public static final String FORMATTER_WRAP_BEFORE_BINARY_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.wrap_before_binary_operator"; //$NON-NLS-1$ 3135 /** 3136     * <pre> 3137     * FORMATTER / The wrapping is done by indenting by one compare to the current indentation. 3138     * </pre> 3139     * @since 3.0 3140     */ 3141    public static final int INDENT_BY_ONE= 2; 3142     3143    /** 3144     * <pre> 3145     * FORMATTER / The wrapping is done by using the current indentation. 3146     * </pre> 3147     * @since 3.0 3148     */ 3149    public static final int INDENT_DEFAULT= 0; 3150    /** 3151     * <pre> 3152     * FORMATTER / The wrapping is done by indenting on column under the splitting location. 3153     * </pre> 3154     * @since 3.0 3155     */ 3156    public static final int INDENT_ON_COLUMN = 1; 3157     3158    /** 3159     * <pre> 3160     * FORMATTER / Possible value for the option FORMATTER_TAB_CHAR 3161     * </pre> 3162     * @since 3.1 3163     * @see JavaCore#TAB 3164     * @see JavaCore#SPACE 3165     * @see #FORMATTER_TAB_CHAR 3166     */ 3167    public static final String MIXED = "mixed"; //$NON-NLS-1$ 3168 /** 3169     * <pre> 3170     * FORMATTER / Value to set a brace location at the start of the next line with 3171     * the right indentation. 3172     * </pre> 3173     * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION 3174     * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER 3175     * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK 3176     * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION 3177     * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION 3178     * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH 3179     * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION 3180     * @since 3.0 3181     */ 3182    public static final String NEXT_LINE = "next_line"; //$NON-NLS-1$ 3183 /** 3184     * <pre> 3185     * FORMATTER / Value to set a brace location at the start of the next line if a wrapping 3186     * occured. 3187     * </pre> 3188     * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION 3189     * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER 3190     * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK 3191     * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION 3192     * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION 3193     * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH 3194     * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION 3195     * @since 3.0 3196     */ 3197    public static final String NEXT_LINE_ON_WRAP = "next_line_on_wrap"; //$NON-NLS-1$ 3198 /** 3199     * <pre> 3200     * FORMATTER / Value to set a brace location at the start of the next line with 3201     * an extra indentation. 3202     * </pre> 3203     * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION 3204     * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER 3205     * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK 3206     * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION 3207     * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION 3208     * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH 3209     * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION 3210     * @since 3.0 3211     */ 3212    public static final String NEXT_LINE_SHIFTED = "next_line_shifted"; //$NON-NLS-1$ 3213 /** 3214     * <pre> 3215     * FORMATTER / Value to set an option to true. 3216     * </pre> 3217     * @since 3.0 3218     */ 3219    public static final String TRUE = "true"; //$NON-NLS-1$ 3220 /** 3221     * <pre> 3222     * FORMATTER / The wrapping is done using as few lines as possible. 3223     * </pre> 3224     * @since 3.0 3225     */ 3226    public static final int WRAP_COMPACT= 1; 3227    /** 3228     * <pre> 3229     * FORMATTER / The wrapping is done putting the first element on a new 3230     * line and then wrapping next elements using as few lines as possible. 3231     * </pre> 3232     * @since 3.0 3233     */ 3234    public static final int WRAP_COMPACT_FIRST_BREAK= 2; 3235    /** 3236     * <pre> 3237     * FORMATTER / The wrapping is done by putting each element on its own line 3238     * except the first element. 3239     * </pre> 3240     * @since 3.0 3241     */ 3242    public static final int WRAP_NEXT_PER_LINE= 5; 3243    /** 3244     * <pre> 3245     * FORMATTER / The wrapping is done by putting each element on its own line. 3246     * All elements are indented by one except the first element. 3247     * </pre> 3248     * @since 3.0 3249     */ 3250    public static final int WRAP_NEXT_SHIFTED= 4; 3251 3252    /** 3253     * <pre> 3254     * FORMATTER / Value to disable alignment. 3255     * </pre> 3256     * @since 3.0 3257     */ 3258    public static final int WRAP_NO_SPLIT= 0; 3259    /** 3260     * <pre> 3261     * FORMATTER / The wrapping is done by putting each element on its own line. 3262     * </pre> 3263     * @since 3.0 3264     */ 3265    public static final int WRAP_ONE_PER_LINE= 3; 3266 3267    /* 3268     * Private constants. Not in javadoc 3269     */ 3270    private static final IllegalArgumentException WRONG_ARGUMENT = new IllegalArgumentException (); 3271    /** 3272     * Create a new alignment value according to the given values. This must be used to set up 3273     * the alignment options. 3274     * 3275     * @param forceSplit the given force value 3276     * @param wrapStyle the given wrapping style 3277     * @param indentStyle the given indent style 3278     * 3279     * @return the new alignement value 3280     */ 3281    public static String createAlignmentValue(boolean forceSplit, int wrapStyle, int indentStyle) { 3282        int alignmentValue = 0; 3283        switch(wrapStyle) { 3284            case WRAP_COMPACT : 3285                alignmentValue |= Alignment.M_COMPACT_SPLIT; 3286                break; 3287            case WRAP_COMPACT_FIRST_BREAK : 3288                alignmentValue |= Alignment.M_COMPACT_FIRST_BREAK_SPLIT; 3289                break; 3290            case WRAP_NEXT_PER_LINE : 3291                alignmentValue |= Alignment.M_NEXT_PER_LINE_SPLIT; 3292                break; 3293            case WRAP_NEXT_SHIFTED : 3294                alignmentValue |= Alignment.M_NEXT_SHIFTED_SPLIT; 3295                break; 3296            case WRAP_ONE_PER_LINE : 3297                alignmentValue |= Alignment.M_ONE_PER_LINE_SPLIT; 3298                break; 3299        } 3300        if (forceSplit) { 3301            alignmentValue |= Alignment.M_FORCE; 3302        } 3303        switch(indentStyle) { 3304            case INDENT_BY_ONE : 3305                alignmentValue |= Alignment.M_INDENT_BY_ONE; 3306                break; 3307            case INDENT_ON_COLUMN : 3308                alignmentValue |= Alignment.M_INDENT_ON_COLUMN; 3309        } 3310        return String.valueOf(alignmentValue); 3311    } 3312 3313    /** 3314     * Returns the formatter settings that most closely approximate 3315     * the default formatter settings of Eclipse version 2.1. 3316     * 3317     * @return the Eclipse 2.1 settings 3318     * @since 3.0 3319     */ 3320    public static Map getEclipse21Settings() { 3321        return DefaultCodeFormatterOptions.getDefaultSettings().getMap(); 3322    } 3323 3324    /** 3325     * Returns the default Eclipse formatter settings 3326     * 3327     * @return the Eclipse default settings 3328     * @since 3.1 3329     */ 3330    public static Map getEclipseDefaultSettings() { 3331        return DefaultCodeFormatterOptions.getEclipseDefaultSettings().getMap(); 3332    } 3333 3334    /** 3335     * <p>Return the force value of the given alignment value. 3336     * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 3337     * API. 3338     * </p> 3339     * 3340     * @param value the given alignment value 3341     * @return the force value of the given alignment value 3342     * @see #createAlignmentValue(boolean, int, int) 3343     * @exception IllegalArgumentException if the given alignment value is null, or if it 3344     * doesn't have a valid format. 3345     */ 3346    public static boolean getForceWrapping(String value) { 3347        if (value == null) { 3348            throw WRONG_ARGUMENT; 3349        } 3350        try { 3351            int existingValue = Integer.parseInt(value); 3352            return (existingValue & Alignment.M_FORCE) != 0; 3353        } catch (NumberFormatException e) { 3354            throw WRONG_ARGUMENT; 3355        } 3356    } 3357     3358    /** 3359     * <p>Return the indentation style of the given alignment value. 3360     * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 3361     * API. 3362     * </p> 3363     * 3364     * @param value the given alignment value 3365     * @return the indentation style of the given alignment value 3366     * @see #createAlignmentValue(boolean, int, int) 3367     * @exception IllegalArgumentException if the given alignment value is null, or if it 3368     * doesn't have a valid format. 3369     */ 3370    public static int getIndentStyle(String value) { 3371        if (value == null) { 3372            throw WRONG_ARGUMENT; 3373        } 3374        try { 3375            int existingValue = Integer.parseInt(value); 3376            if ((existingValue & Alignment.M_INDENT_BY_ONE) != 0) { 3377                return INDENT_BY_ONE; 3378            } else if ((existingValue & Alignment.M_INDENT_ON_COLUMN) != 0) { 3379                return INDENT_ON_COLUMN; 3380            } else { 3381                return INDENT_DEFAULT; 3382            } 3383        } catch (NumberFormatException e) { 3384            throw WRONG_ARGUMENT; 3385        } 3386    } 3387 3388    /** 3389     * Returns the settings according to the Java conventions. 3390     * 3391     * @return the settings according to the Java conventions 3392     * @since 3.0 3393     */ 3394    public static Map getJavaConventionsSettings() { 3395        return DefaultCodeFormatterOptions.getJavaConventionsSettings().getMap(); 3396    } 3397    /** 3398     * <p>Return the wrapping style of the given alignment value. 3399     * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 3400     * API. 3401     * </p> 3402     * 3403     * @param value the given alignment value 3404     * @return the wrapping style of the given alignment value 3405     * @see #createAlignmentValue(boolean, int, int) 3406     * @exception IllegalArgumentException if the given alignment value is null, or if it 3407     * doesn't have a valid format. 3408     */ 3409    public static int getWrappingStyle(String value) { 3410        if (value == null) { 3411            throw WRONG_ARGUMENT; 3412        } 3413        try { 3414            int existingValue = Integer.parseInt(value) & Alignment.SPLIT_MASK; 3415            switch(existingValue) { 3416                case Alignment.M_COMPACT_SPLIT : 3417                    return WRAP_COMPACT; 3418                case Alignment.M_COMPACT_FIRST_BREAK_SPLIT : 3419                    return WRAP_COMPACT_FIRST_BREAK; 3420                case Alignment.M_NEXT_PER_LINE_SPLIT : 3421                    return WRAP_NEXT_PER_LINE; 3422                case Alignment.M_NEXT_SHIFTED_SPLIT : 3423                    return WRAP_NEXT_SHIFTED; 3424                case Alignment.M_ONE_PER_LINE_SPLIT : 3425                    return WRAP_ONE_PER_LINE; 3426                default: 3427                    return WRAP_NO_SPLIT; 3428            } 3429        } catch (NumberFormatException e) { 3430            throw WRONG_ARGUMENT; 3431        } 3432    } 3433    /** 3434     * <p>Set the force value of the given alignment value and return the new value. 3435     * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 3436     * API. 3437     * </p> 3438     * 3439     * @param value the given alignment value 3440     * @param force the given force value 3441     * @return the new alignment value 3442     * @see #createAlignmentValue(boolean, int, int) 3443     * @exception IllegalArgumentException if the given alignment value is null, or if it 3444     * doesn't have a valid format. 3445     */ 3446    public static String setForceWrapping(String value, boolean force) { 3447        if (value == null) { 3448            throw WRONG_ARGUMENT; 3449        } 3450        try { 3451            int existingValue = Integer.parseInt(value); 3452            // clear existing force bit 3453 existingValue &= ~Alignment.M_FORCE; 3454            if (force) { 3455                existingValue |= Alignment.M_FORCE; 3456            } 3457            return String.valueOf(existingValue); 3458        } catch (NumberFormatException e) { 3459            throw WRONG_ARGUMENT; 3460        } 3461    } 3462     3463    /** 3464     * <p>Set the indentation style of the given alignment value and return the new value. 3465     * The given value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 3466     * API. 3467     * </p> 3468     * 3469     * @param value the given alignment value 3470     * @param indentStyle the given indentation style 3471     * @return the new alignment value 3472     * @see #INDENT_BY_ONE 3473     * @see #INDENT_DEFAULT 3474     * @see #INDENT_ON_COLUMN 3475     * @see #createAlignmentValue(boolean, int, int) 3476     * @exception IllegalArgumentException if the given alignment value is null, if the given 3477     * indentation style is not one of the possible indentation styles, or if the given 3478     * alignment value doesn't have a valid format. 3479     */ 3480    public static String setIndentStyle(String value, int indentStyle) { 3481        if (value == null) { 3482            throw WRONG_ARGUMENT; 3483        } 3484        switch(indentStyle) { 3485            case INDENT_BY_ONE : 3486            case INDENT_DEFAULT : 3487            case INDENT_ON_COLUMN : 3488                break; 3489            default : 3490                throw WRONG_ARGUMENT; 3491        } 3492        try { 3493            int existingValue = Integer.parseInt(value); 3494            // clear existing indent bits 3495 existingValue &= ~(Alignment.M_INDENT_BY_ONE | Alignment.M_INDENT_ON_COLUMN); 3496            switch(indentStyle) { 3497                case INDENT_BY_ONE : 3498                    existingValue |= Alignment.M_INDENT_BY_ONE; 3499                    break; 3500                case INDENT_ON_COLUMN : 3501                    existingValue |= Alignment.M_INDENT_ON_COLUMN; 3502            } 3503            return String.valueOf(existingValue); 3504        } catch (NumberFormatException e) { 3505            throw WRONG_ARGUMENT; 3506        } 3507    } 3508    /** 3509     * <p>Set the wrapping style of the given alignment value and return the new value. 3510     * The given value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 3511     * API. 3512     * </p> 3513     * 3514     * @param value the given alignment value 3515     * @param wrappingStyle the given wrapping style 3516     * @return the new alignment value 3517     * @see #WRAP_COMPACT 3518     * @see #WRAP_COMPACT_FIRST_BREAK 3519     * @see #WRAP_NEXT_PER_LINE 3520     * @see #WRAP_NEXT_SHIFTED 3521     * @see #WRAP_NO_SPLIT 3522     * @see #WRAP_ONE_PER_LINE 3523     * @see #createAlignmentValue(boolean, int, int) 3524     * @exception IllegalArgumentException if the given alignment value is null, if the given 3525     * wrapping style is not one of the possible wrapping styles, or if the given 3526     * alignment value doesn't have a valid format. 3527     */ 3528    public static String setWrappingStyle(String value, int wrappingStyle) { 3529        if (value == null) { 3530            throw WRONG_ARGUMENT; 3531        } 3532        switch(wrappingStyle) { 3533            case WRAP_COMPACT : 3534            case WRAP_COMPACT_FIRST_BREAK : 3535            case WRAP_NEXT_PER_LINE : 3536            case WRAP_NEXT_SHIFTED : 3537            case WRAP_NO_SPLIT : 3538            case WRAP_ONE_PER_LINE : 3539                break; 3540            default: 3541                throw WRONG_ARGUMENT; 3542        } 3543        try { 3544            int existingValue = Integer.parseInt(value); 3545            // clear existing split bits 3546 existingValue &= ~(Alignment.SPLIT_MASK); 3547            switch(wrappingStyle) { 3548                case WRAP_COMPACT : 3549                    existingValue |= Alignment.M_COMPACT_SPLIT; 3550                    break; 3551                case WRAP_COMPACT_FIRST_BREAK : 3552                    existingValue |= Alignment.M_COMPACT_FIRST_BREAK_SPLIT; 3553                    break; 3554                case WRAP_NEXT_PER_LINE : 3555                    existingValue |= Alignment.M_NEXT_PER_LINE_SPLIT; 3556                    break; 3557                case WRAP_NEXT_SHIFTED : 3558                    existingValue |= Alignment.M_NEXT_SHIFTED_SPLIT; 3559                    break; 3560                case WRAP_ONE_PER_LINE : 3561                    existingValue |= Alignment.M_ONE_PER_LINE_SPLIT; 3562                    break; 3563            } 3564            return String.valueOf(existingValue); 3565        } catch (NumberFormatException e) { 3566            throw WRONG_ARGUMENT; 3567        } 3568    } 3569} 3570

A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame Popular Tags