1 /******************************************************************************* 2 * Copyright (c) 2000, 2019 IBM Corporation and others. 3 * 4 * This program and the accompanying materials 5 * are made available under the terms of the Eclipse Public License 2.0 6 * which accompanies this distribution, and is available at 7 * https://www.eclipse.org/legal/epl-2.0/ 8 * 9 * SPDX-License-Identifier: EPL-2.0 10 * 11 * Contributors: 12 * IBM Corporation - initial API and implementation 13 * Brock Janiczak - Contribution for bug 150741 14 * Ray V. (voidstar@gmail.com) - Contribution for bug 282988 15 * Jesper S Moller - Contribution for bug 402173 16 * Mateusz Matela <mateusz.matela@gmail.com> - [formatter] Formatter does not format Java code correctly, especially when max line width is set - https://bugs.eclipse.org/303519 17 *******************************************************************************/ 18 package org.eclipse.jdt.core.formatter; 19 20 import java.util.Map; 21 22 import org.eclipse.jdt.core.JavaCore; 23 import org.eclipse.jdt.core.ToolFactory; 24 import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions; 25 import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions.Alignment; 26 27 /** 28 * Constants used to set up the options of the code formatter. 29 * 30 * @since 3.0 31 * @noinstantiate This class is not intended to be instantiated by clients. 32 * @noextend This class is not intended to be subclassed by clients. 33 */ 34 @SuppressWarnings("rawtypes") 35 public class DefaultCodeFormatterConstants { 36 37 /** 38 * <pre> 39 * FORMATTER / Value to set a brace location at the end of a line. 40 * </pre> 41 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION 42 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER 43 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK 44 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION 45 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION 46 * @see #FORMATTER_BRACE_POSITION_FOR_RECORD_CONSTRUCTOR 47 * @see #FORMATTER_BRACE_POSITION_FOR_RECORD_DECLARATION 48 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH 49 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION 50 * @see #FORMATTER_BRACE_POSITION_FOR_LAMBDA_BODY 51 * @since 3.0 52 */ 53 public static final String END_OF_LINE = "end_of_line"; //$NON-NLS-1$ 54 55 /** 56 * <pre> 57 * FORMATTER / Value to set an option to false. 58 * </pre> 59 * @since 3.0 60 */ 61 public static final String FALSE = "false"; //$NON-NLS-1$ 62 63 /** 64 * <pre> 65 * FORMATTER / Option to align type members of a type declaration on column 66 * - option id: "org.eclipse.jdt.core.formatter.align_type_members_on_columns" 67 * - possible values: { TRUE, FALSE } 68 * - default: FALSE 69 * </pre> 70 * @see #TRUE 71 * @see #FALSE 72 * @since 3.0 73 */ 74 public static final String FORMATTER_ALIGN_TYPE_MEMBERS_ON_COLUMNS = JavaCore.PLUGIN_ID + ".formatter.align_type_members_on_columns"; //$NON-NLS-1$ 75 76 /** 77 * <pre> 78 * FORMATTER / Option to align variable declarations on column 79 * - option id: "org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns" 80 * - possible values: { TRUE, FALSE } 81 * - default: FALSE 82 * </pre> 83 * @see #TRUE 84 * @see #FALSE 85 * @since 3.15 86 */ 87 public static final String FORMATTER_ALIGN_VARIABLE_DECLARATIONS_ON_COLUMNS = JavaCore.PLUGIN_ID + ".formatter.align_variable_declarations_on_columns"; //$NON-NLS-1$ 88 89 /** 90 * <pre> 91 * FORMATTER / Option to align assignment statements on column 92 * - option id: "org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns" 93 * - possible values: { TRUE, FALSE } 94 * - default: FALSE 95 * </pre> 96 * @see #TRUE 97 * @see #FALSE 98 * @since 3.15 99 */ 100 public static final String FORMATTER_ALIGN_ASSIGNMENT_STATEMENTS_ON_COLUMNS = JavaCore.PLUGIN_ID + ".formatter.align_assignment_statements_on_columns"; //$NON-NLS-1$ 101 102 /** 103 * <pre> 104 * FORMATTER / Option to use spaces when aligning members, independent of selected tabulation character 105 * - option id: "org.eclipse.jdt.core.formatter.align_with_spaces" 106 * - possible values: { TRUE, FALSE } 107 * - default: FALSE 108 * </pre> 109 * @see #TRUE 110 * @see #FALSE 111 * @since 3.15 112 */ 113 public static final String FORMATTER_ALIGN_WITH_SPACES = JavaCore.PLUGIN_ID + ".formatter.align_with_spaces"; //$NON-NLS-1$ 114 115 /** 116 * <pre> 117 * FORMATTER / Option to affect aligning on columns: groups of items are aligned independently 118 * if they are separated by at least the selected number of blank lines. 119 * Note: since 3.15 the 'fields' part is a (potentially misleading) residue as this option 120 * affects other types of aligning on columns as well. 121 * - option id: "org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines" 122 * - possible values: "<n>", where n is a positive integer 123 * - default: {@code Integer.MAX_VALUE} 124 * </pre> 125 * @since 3.12 126 */ 127 public static final String FORMATTER_ALIGN_FIELDS_GROUPING_BLANK_LINES = JavaCore.PLUGIN_ID + ".formatter.align_fields_grouping_blank_lines"; //$NON-NLS-1$ 128 129 /** 130 * <pre> 131 * FORMATTER / Option for alignment of arguments in allocation expression 132 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" 133 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 134 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 135 * </pre> 136 * @see #createAlignmentValue(boolean, int, int) 137 * @since 3.0 138 */ 139 public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ALLOCATION_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_arguments_in_allocation_expression"; //$NON-NLS-1$ 140 /** 141 * <pre> 142 * FORMATTER / Option for alignment of arguments in enum constant 143 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant" 144 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 145 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 146 * </pre> 147 * @see #createAlignmentValue(boolean, int, int) 148 * @since 3.1 149 */ 150 public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.alignment_for_arguments_in_enum_constant"; //$NON-NLS-1$ 151 /** 152 * <pre> 153 * FORMATTER / Option for alignment of arguments in annotation 154 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation" 155 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 156 * - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT) 157 * </pre> 158 * @see #createAlignmentValue(boolean, int, int) 159 * @since 3.6 160 */ 161 public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_arguments_in_annotation"; //$NON-NLS-1$ 162 /** 163 * <pre> 164 * FORMATTER / Option for alignment of arguments in explicit constructor call 165 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call" 166 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 167 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 168 * </pre> 169 * @see #createAlignmentValue(boolean, int, int) 170 * @since 3.0 171 */ 172 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$ 173 /** 174 * <pre> 175 * FORMATTER / Option for alignment of arguments in method invocation 176 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation" 177 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 178 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 179 * </pre> 180 * @see #createAlignmentValue(boolean, int, int) 181 * @since 3.0 182 */ 183 public static final String FORMATTER_ALIGNMENT_FOR_ARGUMENTS_IN_METHOD_INVOCATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_arguments_in_method_invocation"; //$NON-NLS-1$ 184 /** 185 * <pre> 186 * FORMATTER / Option for alignment of arguments in qualified allocation expression 187 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression" 188 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 189 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 190 * </pre> 191 * @see #createAlignmentValue(boolean, int, int) 192 * @since 3.0 193 */ 194 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$ 195 /** 196 * <pre> 197 * FORMATTER / Option for alignment of assignment (=, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=, >>>=) 198 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_assignment" 199 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 200 * - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT) 201 * </pre> 202 * @see #createAlignmentValue(boolean, int, int) 203 * @since 3.2 204 */ 205 public static final String FORMATTER_ALIGNMENT_FOR_ASSIGNMENT = JavaCore.PLUGIN_ID + ".formatter.alignment_for_assignment"; //$NON-NLS-1$ 206 /** 207 * <pre> 208 * FORMATTER / Option for alignment of expressions with multiplicative operators (*, /, %) 209 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator" 210 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 211 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 212 * </pre> 213 * @see #createAlignmentValue(boolean, int, int) 214 * @since 3.17 215 */ 216 public static final String FORMATTER_ALIGNMENT_FOR_MULTIPLICATIVE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.alignment_for_multiplicative_operator"; //$NON-NLS-1$ 217 /** 218 * <pre> 219 * FORMATTER / Option for alignment of expressions with additive operators (+, -) 220 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_additive_operator" 221 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 222 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 223 * </pre> 224 * @see #createAlignmentValue(boolean, int, int) 225 * @since 3.17 226 */ 227 public static final String FORMATTER_ALIGNMENT_FOR_ADDITIVE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.alignment_for_additive_operator"; //$NON-NLS-1$ 228 /** 229 * <pre> 230 * FORMATTER / Option for alignment of string concatenation expressions 231 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_string_concatenation" 232 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 233 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 234 * </pre> 235 * @see #createAlignmentValue(boolean, int, int) 236 * @since 3.17 237 */ 238 public static final String FORMATTER_ALIGNMENT_FOR_STRING_CONCATENATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_string_concatenation"; //$NON-NLS-1$ 239 /** 240 * <pre> 241 * FORMATTER / Option for alignment of expressions with shift operators (<<, >>, >>>) 242 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_shift_operator" 243 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 244 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 245 * </pre> 246 * @see #createAlignmentValue(boolean, int, int) 247 * @since 3.17 248 */ 249 public static final String FORMATTER_ALIGNMENT_FOR_SHIFT_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.alignment_for_shift_operator"; //$NON-NLS-1$ 250 /** 251 * <pre> 252 * FORMATTER / Option for alignment of expressions with relational operators (<, >, <=, >=, ==, !=) 253 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_relational_operator" 254 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 255 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 256 * </pre> 257 * @see #createAlignmentValue(boolean, int, int) 258 * @since 3.17 259 */ 260 public static final String FORMATTER_ALIGNMENT_FOR_RELATIONAL_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.alignment_for_relational_operator"; //$NON-NLS-1$ 261 /** 262 * <pre> 263 * FORMATTER / Option for alignment of expressions with bitwise operators (&, ^, |) 264 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator" 265 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 266 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 267 * </pre> 268 * @see #createAlignmentValue(boolean, int, int) 269 * @since 3.17 270 */ 271 public static final String FORMATTER_ALIGNMENT_FOR_BITWISE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.alignment_for_bitwise_operator"; //$NON-NLS-1$ 272 /** 273 * <pre> 274 * FORMATTER / Option for alignment of expressions with logical operators (&&, ||) 275 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_logical_operator" 276 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 277 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 278 * </pre> 279 * @see #createAlignmentValue(boolean, int, int) 280 * @since 3.17 281 */ 282 public static final String FORMATTER_ALIGNMENT_FOR_LOGICAL_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.alignment_for_logical_operator"; //$NON-NLS-1$ 283 /** 284 * <pre> 285 * FORMATTER / Option for alignment of binary expression 286 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_binary_expression" 287 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 288 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 289 * </pre> 290 * 291 * @see #createAlignmentValue(boolean, int, int) 292 * @since 3.0 293 * @deprecated Use new settings instead: {@link #FORMATTER_ALIGNMENT_FOR_MULTIPLICATIVE_OPERATOR}, 294 * {@link #FORMATTER_ALIGNMENT_FOR_ADDITIVE_OPERATOR}, {@link #FORMATTER_ALIGNMENT_FOR_STRING_CONCATENATION}, 295 * {@link #FORMATTER_ALIGNMENT_FOR_BITWISE_OPERATOR}, {@link #FORMATTER_ALIGNMENT_FOR_LOGICAL_OPERATOR} 296 */ 297 public static final String FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_binary_expression"; //$NON-NLS-1$ 298 /** 299 * <pre> 300 * FORMATTER / Option for alignment of compact if 301 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_compact_if" 302 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 303 * - default: createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_BY_ONE) 304 * </pre> 305 * @see #createAlignmentValue(boolean, int, int) 306 * @since 3.0 307 */ 308 public static final String FORMATTER_ALIGNMENT_FOR_COMPACT_IF = JavaCore.PLUGIN_ID + ".formatter.alignment_for_compact_if"; //$NON-NLS-1$ 309 /** 310 * <pre> 311 * FORMATTER / Option for alignment of compact loops 312 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_compact_loops" 313 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 314 * - default: createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_BY_ONE) 315 * </pre> 316 * @see #createAlignmentValue(boolean, int, int) 317 * @since 3.15 318 */ 319 public static final String FORMATTER_ALIGNMENT_FOR_COMPACT_LOOP = JavaCore.PLUGIN_ID + ".formatter.alignment_for_compact_loops"; //$NON-NLS-1$ 320 /** 321 * <pre> 322 * FORMATTER / Option for alignment of conditional expression 323 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" 324 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 325 * - default: createAlignmentValue(false, WRAP_ONE_PER_LINE, INDENT_DEFAULT) 326 * </pre> 327 * @see #createAlignmentValue(boolean, int, int) 328 * @see #FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION_CHAIN 329 * @since 3.0 330 */ 331 public static final String FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_conditional_expression"; //$NON-NLS-1$ 332 /** 333 * <pre> 334 * FORMATTER / Option for alignment of conditional expression chains. If disabled, chains are not recognized 335 * and only {@link #FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION} policy is used instead. 336 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain" 337 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 338 * - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT) 339 * </pre> 340 * @see #createAlignmentValue(boolean, int, int) 341 * @see #FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION 342 * @since 3.18 343 */ 344 public static final String FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION_CHAIN = JavaCore.PLUGIN_ID + ".formatter.alignment_for_conditional_expression_chain"; //$NON-NLS-1$ 345 /** 346 * <pre> 347 * FORMATTER / Option for alignment of enum constants 348 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_enum_constants" 349 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 350 * - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT) 351 * </pre> 352 * @see #createAlignmentValue(boolean, int, int) 353 * @since 3.1 354 */ 355 public static final String FORMATTER_ALIGNMENT_FOR_ENUM_CONSTANTS = JavaCore.PLUGIN_ID + ".formatter.alignment_for_enum_constants"; //$NON-NLS-1$ 356 /** 357 * <pre> 358 * FORMATTER / Option for alignment of expressions in array initializer 359 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer" 360 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 361 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 362 * </pre> 363 * @see #createAlignmentValue(boolean, int, int) 364 * @since 3.0 365 */ 366 public static final String FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.alignment_for_expressions_in_array_initializer"; //$NON-NLS-1$ 367 /** 368 * <pre> 369 * FORMATTER / Option for alignment of initialization, termination, and increment expressions in 'for' 370 * loop header 371 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_for_loop_header" 372 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 373 * - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT) 374 * </pre> 375 * @see #createAlignmentValue(boolean, int, int) 376 * @since 3.12 377 */ 378 public static final String FORMATTER_ALIGNMENT_FOR_EXPRESSIONS_IN_FOR_LOOP_HEADER = JavaCore.PLUGIN_ID + ".formatter.alignment_for_expressions_in_for_loop_header"; //$NON-NLS-1$ 379 /** 380 * <pre> 381 * FORMATTER / Option for alignment of method declaration 382 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_method_declaration" 383 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 384 * - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT) 385 * </pre> 386 * @see #createAlignmentValue(boolean, int, int) 387 * @since 3.6 388 */ 389 public static final String FORMATTER_ALIGNMENT_FOR_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_method_declaration"; //$NON-NLS-1$ 390 /** 391 * <pre> 392 * FORMATTER / Option for alignment of module statements 393 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_module_statements" 394 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 395 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 396 * </pre> 397 * @see #createAlignmentValue(boolean, int, int) 398 * @since 3.14 399 */ 400 public static final String FORMATTER_ALIGNMENT_FOR_MODULE_STATEMENTS = JavaCore.PLUGIN_ID + ".formatter.alignment_for_module_statements"; //$NON-NLS-1$ 401 /** 402 * <pre> 403 * FORMATTER / Option for alignment of multiple fields 404 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_multiple_fields" 405 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 406 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 407 * </pre> 408 * @see #createAlignmentValue(boolean, int, int) 409 * @since 3.0 410 */ 411 public static final String FORMATTER_ALIGNMENT_FOR_MULTIPLE_FIELDS = JavaCore.PLUGIN_ID + ".formatter.alignment_for_multiple_fields";//$NON-NLS-1$ 412 /** 413 * <pre> 414 * FORMATTER / Option for alignment of type arguments in parameterized type references 415 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references" 416 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 417 * - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT) 418 * </pre> 419 * @see #createAlignmentValue(boolean, int, int) 420 * @since 3.12 421 */ 422 public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERIZED_TYPE_REFERENCES = JavaCore.PLUGIN_ID + ".formatter.alignment_for_parameterized_type_references"; //$NON-NLS-1$ 423 424 /** 425 * <pre> 426 * FORMATTER / Option for alignment of parameters in constructor declaration 427 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" 428 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 429 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 430 * </pre> 431 * @see #createAlignmentValue(boolean, int, int) 432 * @since 3.0 433 */ 434 public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_CONSTRUCTOR_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_parameters_in_constructor_declaration"; //$NON-NLS-1$ 435 /** 436 * <pre> 437 * FORMATTER / Option for alignment of parameters in method declaration 438 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" 439 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 440 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 441 * </pre> 442 * @see #createAlignmentValue(boolean, int, int) 443 * @since 3.0 444 */ 445 public static final String FORMATTER_ALIGNMENT_FOR_PARAMETERS_IN_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_parameters_in_method_declaration"; //$NON-NLS-1$ 446 /** 447 * <pre> 448 * FORMATTER / Option for alignment of components in record declaration 449 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_record_components" 450 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 451 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 452 * </pre> 453 * @see #createAlignmentValue(boolean, int, int) 454 * @since 3.22 455 */ 456 public static final String FORMATTER_ALIGNMENT_FOR_RECORD_COMPONENTS = JavaCore.PLUGIN_ID + ".formatter.alignment_for_record_components"; //$NON-NLS-1$ 457 /** 458 * <pre> 459 * FORMATTER / Option for alignment of resources in a try with resources statement 460 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_resources_in_try" 461 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 462 * - default: createAlignmentValue(false, WRAP_NEXT_PER_LINE, INDENT_DEFAULT) 463 * </pre> 464 * @see #createAlignmentValue(boolean, int, int) 465 * @since 3.7.1 466 */ 467 public static final String FORMATTER_ALIGNMENT_FOR_RESOURCES_IN_TRY = JavaCore.PLUGIN_ID + ".formatter.alignment_for_resources_in_try"; //$NON-NLS-1$ 468 /** 469 * <pre> 470 * FORMATTER / Option for alignment of selector in method invocation 471 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation" 472 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 473 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 474 * </pre> 475 * @see #createAlignmentValue(boolean, int, int) 476 * @since 3.0 477 */ 478 public static final String FORMATTER_ALIGNMENT_FOR_SELECTOR_IN_METHOD_INVOCATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_selector_in_method_invocation"; //$NON-NLS-1$ 479 /** 480 * <pre> 481 * FORMATTER / Option for alignment of superclass in type declaration 482 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration" 483 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 484 * - default: createAlignmentValue(false, WRAP_NEXT_SHIFTED, INDENT_DEFAULT) 485 * </pre> 486 * @see #createAlignmentValue(boolean, int, int) 487 * @since 3.0 488 */ 489 public static final String FORMATTER_ALIGNMENT_FOR_SUPERCLASS_IN_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_superclass_in_type_declaration"; //$NON-NLS-1$ 490 /** 491 * <pre> 492 * FORMATTER / Option for alignment of superinterfaces in enum declaration 493 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration" 494 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 495 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 496 * </pre> 497 * @see #createAlignmentValue(boolean, int, int) 498 * @since 3.1 499 */ 500 public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_ENUM_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_enum_declaration"; //$NON-NLS-1$ 501 /** 502 * <pre> 503 * FORMATTER / Option for alignment of superinterfaces in record declaration 504 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_record_declaration" 505 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 506 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 507 * </pre> 508 * @see #createAlignmentValue(boolean, int, int) 509 * @since 3.22 510 */ 511 public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_RECORD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_record_declaration"; //$NON-NLS-1$ 512 /** 513 * <pre> 514 * FORMATTER / Option for alignment of superinterfaces in type declaration 515 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration" 516 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 517 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 518 * </pre> 519 * @see #createAlignmentValue(boolean, int, int) 520 * @since 3.0 521 */ 522 public static final String FORMATTER_ALIGNMENT_FOR_SUPERINTERFACES_IN_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.alignment_for_superinterfaces_in_type_declaration"; //$NON-NLS-1$ 523 /** 524 * <pre> 525 * FORMATTER / Option for alignment of throws clause in constructor declaration 526 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" 527 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 528 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 529 * </pre> 530 * @see #createAlignmentValue(boolean, int, int) 531 * @since 3.0 532 */ 533 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$ 534 /** 535 * <pre> 536 * FORMATTER / Option for alignment of throws clause in method declaration 537 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" 538 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 539 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 540 * </pre> 541 * @see #createAlignmentValue(boolean, int, int) 542 * @since 3.0 543 */ 544 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$ 545 /** 546 * <pre> 547 * FORMATTER / Option for alignment of type arguments in method invocations and references 548 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_type_arguments" 549 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 550 * - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT) 551 * </pre> 552 * @see #createAlignmentValue(boolean, int, int) 553 * @since 3.12 554 */ 555 public static final String FORMATTER_ALIGNMENT_FOR_TYPE_ARGUMENTS = JavaCore.PLUGIN_ID + ".formatter.alignment_for_type_arguments"; //$NON-NLS-1$ 556 /** 557 * <pre> 558 * FORMATTER / Option for alignment of type parameters in method and type declarations 559 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_type_parameters" 560 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 561 * - default: createAlignmentValue(false, WRAP_NO_SPLIT, INDENT_DEFAULT) 562 * </pre> 563 * @see #createAlignmentValue(boolean, int, int) 564 * @since 3.12 565 */ 566 public static final String FORMATTER_ALIGNMENT_FOR_TYPE_PARAMETERS = JavaCore.PLUGIN_ID + ".formatter.alignment_for_type_parameters"; //$NON-NLS-1$ 567 /** 568 * <pre> 569 * FORMATTER / Option for alignment of exceptions declared in a Union Type in the argument of a multicatch statement 570 * - option id: "org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch" 571 * - possible values: values returned by <code>createAlignmentValue(boolean, int, int)</code> call 572 * - default: createAlignmentValue(false, WRAP_COMPACT, INDENT_DEFAULT) 573 * </pre> 574 * @see #createAlignmentValue(boolean, int, int) 575 * @since 3.7.1 576 */ 577 public static final String FORMATTER_ALIGNMENT_FOR_UNION_TYPE_IN_MULTICATCH = JavaCore.PLUGIN_ID + ".formatter.alignment_for_union_type_in_multicatch"; //$NON-NLS-1$ 578 /** 579 * <pre> 580 * FORMATTER / Option to add or remove blank lines after the imports declaration 581 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_after_imports" 582 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 583 * blank lines is ~n and any excess blank lines are deleted, overriding the 584 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 585 * - default: "0" 586 * </pre> 587 * @since 3.0 588 */ 589 public static final String FORMATTER_BLANK_LINES_AFTER_IMPORTS = JavaCore.PLUGIN_ID + ".formatter.blank_lines_after_imports"; //$NON-NLS-1$ 590 /** 591 * <pre> 592 * FORMATTER / Option to add or remove blank lines after the package declaration 593 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_after_package" 594 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 595 * blank lines is ~n and any excess blank lines are deleted, overriding the 596 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 597 * - default: "0" 598 * </pre> 599 * @since 3.0 600 */ 601 public static final String FORMATTER_BLANK_LINES_AFTER_PACKAGE = JavaCore.PLUGIN_ID + ".formatter.blank_lines_after_package"; //$NON-NLS-1$ 602 /** 603 * <pre> 604 * FORMATTER / Option to add or remove blank lines at the beginning of the method body 605 * - option id: "org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body" 606 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 607 * blank lines is ~n and any excess blank lines are deleted, overriding the 608 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 609 * - default: "0" 610 * </pre> 611 * @since 3.0 612 */ 613 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$ 614 /** 615 * <pre> 616 * FORMATTER / Option to add or remove blank lines at the end of the method body 617 * - option id: "org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_method_body" 618 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 619 * blank lines is ~n and any excess blank lines are deleted, overriding the 620 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 621 * - default: "0" 622 * </pre> 623 * @since 3.19 624 */ 625 public static final String FORMATTER_BLANK_LINES_AT_END_OF_METHOD_BODY = JavaCore.PLUGIN_ID + ".formatter.number_of_blank_lines_at_end_of_method_body"; //$NON-NLS-1$ 626 /** 627 * <pre> 628 * FORMATTER / Option to add or remove blank lines at the beginning of the code block 629 * - option id: "org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_code_block" 630 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 631 * blank lines is ~n and any excess blank lines are deleted, overriding the 632 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 633 * - default: "0" 634 * </pre> 635 * @since 3.19 636 */ 637 public static final String FORMATTER_BLANK_LINES_AT_BEGINNING_OF_CODE_BLOCK = JavaCore.PLUGIN_ID + ".formatter.number_of_blank_lines_at_beginning_of_code_block"; //$NON-NLS-1$ 638 /** 639 * <pre> 640 * FORMATTER / Option to add or remove blank lines at the end of the code block 641 * - option id: "org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block" 642 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 643 * blank lines is ~n and any excess blank lines are deleted, overriding the 644 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 645 * - default: "0" 646 * </pre> 647 * @since 3.19 648 */ 649 public static final String FORMATTER_BLANK_LINES_AT_END_OF_CODE_BLOCK = JavaCore.PLUGIN_ID + ".formatter.number_of_blank_lines_at_end_of_code_block"; //$NON-NLS-1$ 650 /** 651 * <pre> 652 * FORMATTER / Option to add or remove blank lines before a statement containing a code block 653 * - option id: "org.eclipse.jdt.core.formatter.number_of_blank_lines_before_code_block" 654 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 655 * blank lines is ~n and any excess blank lines are deleted, overriding the 656 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 657 * - default: "0" 658 * </pre> 659 * @since 3.19 660 */ 661 public static final String FORMATTER_BLANK_LINES_BEFORE_CODE_BLOCK = JavaCore.PLUGIN_ID + ".formatter.number_of_blank_lines_before_code_block"; //$NON-NLS-1$ 662 /** 663 * <pre> 664 * FORMATTER / Option to add or remove blank lines after a statement containing a code block 665 * - option id: "org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block" 666 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 667 * blank lines is ~n and any excess blank lines are deleted, overriding the 668 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 669 * - default: "0" 670 * </pre> 671 * @since 3.19 672 */ 673 public static final String FORMATTER_BLANK_LINES_AFTER_CODE_BLOCK = JavaCore.PLUGIN_ID + ".formatter.number_of_blank_lines_after_code_block"; //$NON-NLS-1$ 674 /** 675 * <pre> 676 * FORMATTER / Option to add or remove blank lines before a field declaration 677 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_field" 678 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 679 * blank lines is ~n and any excess blank lines are deleted, overriding the 680 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 681 * - default: "0" 682 * </pre> 683 * @since 3.0 684 */ 685 public static final String FORMATTER_BLANK_LINES_BEFORE_FIELD = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_field"; //$NON-NLS-1$ 686 /** 687 * <pre> 688 * FORMATTER / Option to add or remove blank lines before the first class body declaration 689 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration" 690 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 691 * blank lines is ~n and any excess blank lines are deleted, overriding the 692 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 693 * - default: "0" 694 * </pre> 695 * @since 3.0 696 */ 697 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$ 698 /** 699 * <pre> 700 * FORMATTER / Option to add or remove blank lines after the last class body declaration 701 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_after_last_class_body_declaration" 702 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 703 * blank lines is ~n and any excess blank lines are deleted, overriding the 704 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 705 * - default: "0" 706 * </pre> 707 * @since 3.19 708 */ 709 public static final String FORMATTER_BLANK_LINES_AFTER_LAST_CLASS_BODY_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.blank_lines_after_last_class_body_declaration"; //$NON-NLS-1$ 710 /** 711 * <pre> 712 * FORMATTER / Option to add or remove blank lines before the imports declaration 713 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_imports" 714 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 715 * blank lines is ~n and any excess blank lines are deleted, overriding the 716 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 717 * - default: "0" 718 * </pre> 719 * @since 3.0 720 */ 721 public static final String FORMATTER_BLANK_LINES_BEFORE_IMPORTS = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_imports"; //$NON-NLS-1$ 722 /** 723 * <pre> 724 * FORMATTER / Option to add or remove blank lines before an abstract method declaration 725 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_abstract_method" 726 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 727 * blank lines is ~n and any excess blank lines are deleted, overriding the 728 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 729 * - default: "0" 730 * </pre> 731 * @since 3.19 732 */ 733 public static final String FORMATTER_BLANK_LINES_BEFORE_ABSTRACT_METHOD = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_abstract_method"; //$NON-NLS-1$ 734 735 /** 736 * <pre> 737 * FORMATTER / Option to add or remove blank lines before a member type declaration 738 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_member_type" 739 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 740 * blank lines is ~n and any excess blank lines are deleted, overriding the 741 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 742 * - default: "0" 743 * </pre> 744 * @since 3.0 745 */ 746 public static final String FORMATTER_BLANK_LINES_BEFORE_MEMBER_TYPE = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_member_type"; //$NON-NLS-1$ 747 /** 748 * <pre> 749 * FORMATTER / Option to add or remove blank lines before a non-abstract method declaration 750 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_method" 751 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 752 * blank lines is ~n and any excess blank lines are deleted, overriding the 753 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 754 * - default: "0" 755 * </pre> 756 * @since 3.0 757 */ 758 public static final String FORMATTER_BLANK_LINES_BEFORE_METHOD = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_method"; //$NON-NLS-1$ 759 /** 760 * <pre> 761 * FORMATTER / Option to add or remove blank lines before a new chunk 762 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk" 763 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 764 * blank lines is ~n and any excess blank lines are deleted, overriding the 765 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 766 * - default: "0" 767 * </pre> 768 * @since 3.0 769 */ 770 public static final String FORMATTER_BLANK_LINES_BEFORE_NEW_CHUNK = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_new_chunk"; //$NON-NLS-1$ 771 /** 772 * <pre> 773 * FORMATTER / Option to add or remove blank lines before the package declaration 774 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_before_package" 775 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 776 * blank lines is ~n and any excess blank lines are deleted, overriding the 777 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 778 * - default: "0" 779 * </pre> 780 * @since 3.0 781 */ 782 public static final String FORMATTER_BLANK_LINES_BEFORE_PACKAGE = JavaCore.PLUGIN_ID + ".formatter.blank_lines_before_package"; //$NON-NLS-1$ 783 /** 784 * <pre> 785 * FORMATTER / Option to add or remove blank lines between import groups 786 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_between_import_groups" 787 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 788 * blank lines is ~n and any excess blank lines are deleted, overriding the 789 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 790 * - default: "1" 791 * </pre> 792 * Note: Import groups are defined once "Organize Import" operation has been executed. The code formatter itself 793 * doesn't define the import groups. 794 * 795 * @since 3.3 796 */ 797 public static final String FORMATTER_BLANK_LINES_BETWEEN_IMPORT_GROUPS = JavaCore.PLUGIN_ID + ".formatter.blank_lines_between_import_groups"; //$NON-NLS-1$ 798 /** 799 * <pre> 800 * FORMATTER / Option to add or remove blank lines between type declarations 801 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" 802 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 803 * blank lines is ~n and any excess blank lines are deleted, overriding the 804 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 805 * - default: "0" 806 * </pre> 807 * @since 3.0 808 */ 809 public static final String FORMATTER_BLANK_LINES_BETWEEN_TYPE_DECLARATIONS = JavaCore.PLUGIN_ID + ".formatter.blank_lines_between_type_declarations"; //$NON-NLS-1$ 810 /** 811 * <pre> 812 * FORMATTER / Option to add or remove blank lines between statement groups in switch 813 * - option id: "org.eclipse.jdt.core.formatter.blank_lines_between_statement_groups_in_switch" 814 * - possible values: "<n>", where n is an integer. If n is negative, the actual number of 815 * blank lines is ~n and any excess blank lines are deleted, overriding the 816 * {@link #FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} option 817 * - default: "0" 818 * </pre> 819 * @since 3.19 820 */ 821 public static final String FORMATTER_BLANK_LINES_BETWEEN_STATEMENT_GROUPS_IN_SWITCH = JavaCore.PLUGIN_ID + ".formatter.blank_lines_between_statement_group_in_switch"; //$NON-NLS-1$ 822 /** 823 * <pre> 824 * FORMATTER / Option to position the braces of an annotation type declaration 825 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration" 826 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 827 * - default: END_OF_LINE 828 * </pre> 829 * @see #END_OF_LINE 830 * @see #NEXT_LINE 831 * @see #NEXT_LINE_SHIFTED 832 * @see #NEXT_LINE_ON_WRAP 833 * @since 3.1 834 */ 835 public static final String FORMATTER_BRACE_POSITION_FOR_ANNOTATION_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_annotation_type_declaration"; //$NON-NLS-1$ 836 /** 837 * <pre> 838 * FORMATTER / Option to position the braces of an anonymous type declaration 839 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration" 840 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 841 * - default: END_OF_LINE 842 * </pre> 843 * @see #END_OF_LINE 844 * @see #NEXT_LINE 845 * @see #NEXT_LINE_SHIFTED 846 * @see #NEXT_LINE_ON_WRAP 847 * @since 3.0 848 */ 849 public static final String FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_anonymous_type_declaration"; //$NON-NLS-1$ 850 /** 851 * <pre> 852 * FORMATTER / Option to position the braces of an array initializer 853 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_array_initializer" 854 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 855 * - default: END_OF_LINE 856 * </pre> 857 * @see #END_OF_LINE 858 * @see #NEXT_LINE 859 * @see #NEXT_LINE_SHIFTED 860 * @see #NEXT_LINE_ON_WRAP 861 * @since 3.0 862 */ 863 public static final String FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_array_initializer"; //$NON-NLS-1$ 864 /** 865 * <pre> 866 * FORMATTER / Option to position the braces of a block 867 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_block" 868 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 869 * - default: END_OF_LINE 870 * </pre> 871 * @see #END_OF_LINE 872 * @see #NEXT_LINE 873 * @see #NEXT_LINE_SHIFTED 874 * @see #NEXT_LINE_ON_WRAP 875 * @since 3.0 876 */ 877 public static final String FORMATTER_BRACE_POSITION_FOR_BLOCK = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_block"; //$NON-NLS-1$ 878 /** 879 * <pre> 880 * FORMATTER / Option to position the braces of a block in a case statement when the block is the first statement following 881 * the case 882 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_block_in_case" 883 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 884 * - default: END_OF_LINE 885 * </pre> 886 * @see #END_OF_LINE 887 * @see #NEXT_LINE 888 * @see #NEXT_LINE_SHIFTED 889 * @see #NEXT_LINE_ON_WRAP 890 * @since 3.0 891 */ 892 public static final String FORMATTER_BRACE_POSITION_FOR_BLOCK_IN_CASE = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_block_in_case"; //$NON-NLS-1$ 893 /** 894 * <pre> 895 * FORMATTER / Option to position the braces of a constructor declaration 896 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration" 897 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 898 * - default: END_OF_LINE 899 * </pre> 900 * @see #END_OF_LINE 901 * @see #NEXT_LINE 902 * @see #NEXT_LINE_SHIFTED 903 * @see #NEXT_LINE_ON_WRAP 904 * @since 3.0 905 */ 906 public static final String FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_constructor_declaration"; //$NON-NLS-1$ 907 /** 908 * <pre> 909 * FORMATTER / Option to position the braces of an enum constant 910 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_enum_constant" 911 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 912 * - default: END_OF_LINE 913 * </pre> 914 * @see #END_OF_LINE 915 * @see #NEXT_LINE 916 * @see #NEXT_LINE_SHIFTED 917 * @see #NEXT_LINE_ON_WRAP 918 * @since 3.1 919 */ 920 public static final String FORMATTER_BRACE_POSITION_FOR_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_enum_constant"; //$NON-NLS-1$ 921 /** 922 * <pre> 923 * FORMATTER / Option to position the braces of an enum declaration 924 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration" 925 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 926 * - default: END_OF_LINE 927 * </pre> 928 * @see #END_OF_LINE 929 * @see #NEXT_LINE 930 * @see #NEXT_LINE_SHIFTED 931 * @see #NEXT_LINE_ON_WRAP 932 * @since 3.1 933 */ 934 public static final String FORMATTER_BRACE_POSITION_FOR_ENUM_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_enum_declaration"; //$NON-NLS-1$ 935 /** 936 * <pre> 937 * FORMATTER / Option to position the braces of a method declaration 938 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_method_declaration" 939 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 940 * - default: END_OF_LINE 941 * </pre> 942 * @see #END_OF_LINE 943 * @see #NEXT_LINE 944 * @see #NEXT_LINE_SHIFTED 945 * @see #NEXT_LINE_ON_WRAP 946 * @since 3.0 947 */ 948 public static final String FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_method_declaration"; //$NON-NLS-1$ 949 /** 950 * <pre> 951 * FORMATTER / Option to position the braces of a record constructor 952 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_record_constructor" 953 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 954 * - default: END_OF_LINE 955 * </pre> 956 * @see #END_OF_LINE 957 * @see #NEXT_LINE 958 * @see #NEXT_LINE_SHIFTED 959 * @see #NEXT_LINE_ON_WRAP 960 * @since 3.22 961 */ 962 public static final String FORMATTER_BRACE_POSITION_FOR_RECORD_CONSTRUCTOR = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_record_constructor"; //$NON-NLS-1$ 963 /** 964 * <pre> 965 * FORMATTER / Option to position the braces of a record declaration 966 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_record_declaration" 967 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 968 * - default: END_OF_LINE 969 * </pre> 970 * @see #END_OF_LINE 971 * @see #NEXT_LINE 972 * @see #NEXT_LINE_SHIFTED 973 * @see #NEXT_LINE_ON_WRAP 974 * @since 3.22 975 */ 976 public static final String FORMATTER_BRACE_POSITION_FOR_RECORD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_record_declaration"; //$NON-NLS-1$ 977 /** 978 * <pre> 979 * FORMATTER / Option to position the braces of a switch statement 980 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_switch" 981 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 982 * - default: END_OF_LINE 983 * </pre> 984 * @see #END_OF_LINE 985 * @see #NEXT_LINE 986 * @see #NEXT_LINE_SHIFTED 987 * @see #NEXT_LINE_ON_WRAP 988 * @since 3.0 989 */ 990 public static final String FORMATTER_BRACE_POSITION_FOR_SWITCH = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_switch"; //$NON-NLS-1$ 991 /** 992 * <pre> 993 * FORMATTER / Option to position the braces of a type declaration 994 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_type_declaration" 995 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 996 * - default: END_OF_LINE 997 * </pre> 998 * @see #END_OF_LINE 999 * @see #NEXT_LINE 1000 * @see #NEXT_LINE_SHIFTED 1001 * @see #NEXT_LINE_ON_WRAP 1002 * @since 3.0 1003 */ 1004 public static final String FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_type_declaration"; //$NON-NLS-1$ 1005 1006 /** 1007 * <pre> 1008 * FORMATTER / Option to position the braces of a lambda block 1009 * - option id: "org.eclipse.jdt.core.formatter.brace_position_for_lambda_body" 1010 * - possible values: { END_OF_LINE, NEXT_LINE, NEXT_LINE_SHIFTED, NEXT_LINE_ON_WRAP } 1011 * - default: END_OF_LINE 1012 * </pre> 1013 * @see #END_OF_LINE 1014 * @see #NEXT_LINE 1015 * @see #NEXT_LINE_SHIFTED 1016 * @see #NEXT_LINE_ON_WRAP 1017 * @since 3.10 1018 */ 1019 public static final String FORMATTER_BRACE_POSITION_FOR_LAMBDA_BODY = JavaCore.PLUGIN_ID + ".formatter.brace_position_for_lambda_body"; //$NON-NLS-1$ 1020 1021 /** 1022 * <pre> 1023 * FORMATTER / Option to position parentheses in method declarations 1024 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_method_declaration" 1025 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_NOT_EMPTY, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1026 * - default: COMMON_LINES 1027 * </pre> 1028 * @see #COMMON_LINES 1029 * @see #SEPARATE_LINES_IF_NOT_EMPTY 1030 * @see #SEPARATE_LINES_IF_WRAPPED 1031 * @see #SEPARATE_LINES 1032 * @see #PRESERVE_POSITIONS 1033 * @since 3.12 1034 */ 1035 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_method_delcaration"; //$NON-NLS-1$ 1036 1037 /** 1038 * <pre> 1039 * FORMATTER / Option to position parentheses in method invocations 1040 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation" 1041 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_NOT_EMPTY, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1042 * - default: COMMON_LINES 1043 * </pre> 1044 * @see #COMMON_LINES 1045 * @see #SEPARATE_LINES_IF_NOT_EMPTY 1046 * @see #SEPARATE_LINES_IF_WRAPPED 1047 * @see #SEPARATE_LINES 1048 * @see #PRESERVE_POSITIONS 1049 * @since 3.12 1050 */ 1051 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_INVOCATION = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_method_invocation"; //$NON-NLS-1$ 1052 1053 /** 1054 * <pre> 1055 * FORMATTER / Option to position parentheses in enum constant declarations 1056 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration" 1057 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_NOT_EMPTY, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1058 * - default: COMMON_LINES 1059 * </pre> 1060 * @see #COMMON_LINES 1061 * @see #SEPARATE_LINES_IF_NOT_EMPTY 1062 * @see #SEPARATE_LINES_IF_WRAPPED 1063 * @see #SEPARATE_LINES 1064 * @see #PRESERVE_POSITIONS 1065 * @since 3.12 1066 */ 1067 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_ENUM_CONSTANT_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_enum_constant_declaration"; //$NON-NLS-1$ 1068 1069 /** 1070 * <pre> 1071 * FORMATTER / Option to position parentheses in record declarations 1072 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_record_declaration" 1073 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_NOT_EMPTY, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1074 * - default: COMMON_LINES 1075 * </pre> 1076 * @see #COMMON_LINES 1077 * @see #SEPARATE_LINES_IF_NOT_EMPTY 1078 * @see #SEPARATE_LINES_IF_WRAPPED 1079 * @see #SEPARATE_LINES 1080 * @see #PRESERVE_POSITIONS 1081 * @since 3.22 1082 */ 1083 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_RECORD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_record_declaration"; //$NON-NLS-1$ 1084 1085 /** 1086 * <pre> 1087 * FORMATTER / Option to position parentheses in 'if' and 'while' statements 1088 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement" 1089 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1090 * - default: COMMON_LINES 1091 * </pre> 1092 * @see #COMMON_LINES 1093 * @see #SEPARATE_LINES_IF_WRAPPED 1094 * @see #SEPARATE_LINES 1095 * @see #PRESERVE_POSITIONS 1096 * @since 3.12 1097 */ 1098 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_IF_WHILE_STATEMENT = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_if_while_statement"; //$NON-NLS-1$ 1099 1100 /** 1101 * <pre> 1102 * FORMATTER / Option to position parentheses in 'for' statements 1103 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statement" 1104 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1105 * - default: COMMON_LINES 1106 * </pre> 1107 * @see #COMMON_LINES 1108 * @see #SEPARATE_LINES_IF_WRAPPED 1109 * @see #SEPARATE_LINES 1110 * @see #PRESERVE_POSITIONS 1111 * @since 3.12 1112 */ 1113 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_FOR_STATEMENT = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_for_statment"; //$NON-NLS-1$ 1114 1115 /** 1116 * <pre> 1117 * FORMATTER / Option to position parentheses in 'switch' statements 1118 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement" 1119 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1120 * - default: COMMON_LINES 1121 * </pre> 1122 * @see #COMMON_LINES 1123 * @see #SEPARATE_LINES_IF_WRAPPED 1124 * @see #SEPARATE_LINES 1125 * @see #PRESERVE_POSITIONS 1126 * @since 3.12 1127 */ 1128 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_SWITCH_STATEMENT = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_switch_statement"; //$NON-NLS-1$ 1129 1130 /** 1131 * <pre> 1132 * FORMATTER / Option to position parentheses in try clauses 1133 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause" 1134 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1135 * - default: COMMON_LINES 1136 * </pre> 1137 * @see #COMMON_LINES 1138 * @see #SEPARATE_LINES_IF_WRAPPED 1139 * @see #SEPARATE_LINES 1140 * @see #PRESERVE_POSITIONS 1141 * @since 3.12 1142 */ 1143 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_TRY_CLAUSE = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_try_clause"; //$NON-NLS-1$ 1144 1145 /** 1146 * <pre> 1147 * FORMATTER / Option to position parentheses in catch clauses 1148 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause" 1149 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1150 * - default: COMMON_LINES 1151 * </pre> 1152 * @see #COMMON_LINES 1153 * @see #SEPARATE_LINES_IF_WRAPPED 1154 * @see #SEPARATE_LINES 1155 * @see #PRESERVE_POSITIONS 1156 * @since 3.12 1157 */ 1158 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_CATCH_CLAUSE = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_catch_clause"; //$NON-NLS-1$ 1159 1160 /** 1161 * <pre> 1162 * FORMATTER / Option to position parentheses in annotations 1163 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation" 1164 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_NOT_EMPTY, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1165 * - default: COMMON_LINES 1166 * </pre> 1167 * @see #COMMON_LINES 1168 * @see #SEPARATE_LINES_IF_NOT_EMPTY 1169 * @see #SEPARATE_LINES_IF_WRAPPED 1170 * @see #SEPARATE_LINES 1171 * @see #PRESERVE_POSITIONS 1172 * @since 3.12 1173 */ 1174 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_annotation"; //$NON-NLS-1$ 1175 1176 /** 1177 * <pre> 1178 * FORMATTER / Option to position parentheses in lambda declarations 1179 * - option id: "org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration" 1180 * - possible values: { COMMON_LINES, SEPARATE_LINES_IF_NOT_EMPTY, SEPARATE_LINES_IF_WRAPPED, SEPARATE_LINES, PRESERVE_POSITIONS } 1181 * - default: COMMON_LINES 1182 * </pre> 1183 * @see #COMMON_LINES 1184 * @see #SEPARATE_LINES_IF_NOT_EMPTY 1185 * @see #SEPARATE_LINES_IF_WRAPPED 1186 * @see #SEPARATE_LINES 1187 * @see #PRESERVE_POSITIONS 1188 * @since 3.12 1189 */ 1190 public static final String FORMATTER_PARENTHESES_POSITIONS_IN_LAMBDA_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.parentheses_positions_in_lambda_declaration"; //$NON-NLS-1$ 1191 1192 /** 1193 * <pre> 1194 * FORMATTER / Option to control whether blank lines are cleared inside comments 1195 * - option id: "org.eclipse.jdt.core.formatter.comment.clear_blank_lines" 1196 * - possible values: { TRUE, FALSE } 1197 * - default: FALSE 1198 * </pre> 1199 * @see #TRUE 1200 * @see #FALSE 1201 * @since 3.1 1202 * @deprecated Use {@link #FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_BLOCK_COMMENT} and {@link #FORMATTER_COMMENT_CLEAR_BLANK_LINES_IN_JAVADOC_COMMENT} 1203 */ 1204 @Deprecated 1205 public final static String FORMATTER_COMMENT_CLEAR_BLANK_LINES = "org.eclipse.jdt.core.formatter.comment.clear_blank_lines"; //$NON-NLS-1$ 1206 1207 /** 1208 * <pre> 1209 * FORMATTER / Option to control whether blank lines are cleared inside javadoc comments 1210 * - option id: "org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment" 1211 * - possible values: { TRUE, FALSE } 1212 * - default: FALSE 1213 * </pre> 1214 * @see #TRUE 1215 * @see #FALSE 1216 * @since 3.3 1217 */ 1218 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$ 1219 1220 /** 1221 * <pre> 1222 * FORMATTER / Option to control whether blank lines are cleared inside block comments 1223 * - option id: "org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment" 1224 * - possible values: { TRUE, FALSE } 1225 * - default: FALSE 1226 * </pre> 1227 * @see #TRUE 1228 * @see #FALSE 1229 * @since 3.3 1230 */ 1231 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$ 1232 1233 /** 1234 * <pre> 1235 * FORMATTER / Option to control whether comments are formatted 1236 * - option id: "org.eclipse.jdt.core.formatter.comment.format_comments" 1237 * - possible values: { TRUE, FALSE } 1238 * - default: TRUE 1239 * </pre> 1240 * @see #TRUE 1241 * @see #FALSE 1242 * @since 3.1 1243 * @deprecated Use multiple settings for each kind of comments. See {@link #FORMATTER_COMMENT_FORMAT_BLOCK_COMMENT}, 1244 * {@link #FORMATTER_COMMENT_FORMAT_JAVADOC_COMMENT} and {@link #FORMATTER_COMMENT_FORMAT_LINE_COMMENT}. 1245 */ 1246 @Deprecated 1247 public final static String FORMATTER_COMMENT_FORMAT = "org.eclipse.jdt.core.formatter.comment.format_comments"; //$NON-NLS-1$ 1248 1249 /** 1250 * <pre> 1251 * FORMATTER / Option to control whether single line comments are formatted 1252 * - option id: "org.eclipse.jdt.core.formatter.comment.format_line_comments" 1253 * - possible values: { TRUE, FALSE } 1254 * - default: TRUE 1255 * </pre> 1256 * @see #TRUE 1257 * @see #FALSE 1258 * @since 3.3 1259 */ 1260 public final static String FORMATTER_COMMENT_FORMAT_LINE_COMMENT = "org.eclipse.jdt.core.formatter.comment.format_line_comments"; //$NON-NLS-1$ 1261 /** 1262 * <pre> 1263 * FORMATTER / Option to format line comments that start on the first column 1264 * - option id: "org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column" 1265 * - possible values: { TRUE, FALSE } 1266 * - default: TRUE 1267 * </pre> 1268 * Note that this option is ignored if either the 1269 * {@link #FORMATTER_COMMENT_FORMAT_LINE_COMMENT} option has been set to 1270 * {@link #FALSE} or the formatter is created with the mode 1271 * {@link ToolFactory#M_FORMAT_NEW}. 1272 * 1273 * @see #TRUE 1274 * @see #FALSE 1275 * @see ToolFactory#createCodeFormatter(Map, int) 1276 * @since 3.6 1277 */ 1278 public static final String FORMATTER_COMMENT_FORMAT_LINE_COMMENT_STARTING_ON_FIRST_COLUMN = JavaCore.PLUGIN_ID + ".formatter.format_line_comment_starting_on_first_column"; //$NON-NLS-1$ 1279 1280 /** 1281 * <pre> 1282 * FORMATTER / Option to control whether the white space between code and line comments should be preserved or replaced with a single space 1283 * - option id: "org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments" 1284 * - possible values: { TRUE, FALSE } 1285 * - default: FALSE 1286 * </pre> 1287 * @see #TRUE 1288 * @see #FALSE 1289 * @since 3.7 1290 */ 1291 public final static String FORMATTER_COMMENT_PRESERVE_WHITE_SPACE_BETWEEN_CODE_AND_LINE_COMMENT = "org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments"; //$NON-NLS-1$ 1292 1293 /** 1294 * <pre> 1295 * FORMATTER / Option to control whether multiple lines comments are formatted 1296 * - option id: "org.eclipse.jdt.core.formatter.comment.format_block_comments" 1297 * - possible values: { TRUE, FALSE } 1298 * - default: TRUE 1299 * </pre> 1300 * @see #TRUE 1301 * @see #FALSE 1302 * @since 3.3 1303 */ 1304 public final static String FORMATTER_COMMENT_FORMAT_BLOCK_COMMENT = "org.eclipse.jdt.core.formatter.comment.format_block_comments"; //$NON-NLS-1$ 1305 1306 /** 1307 * <pre> 1308 * FORMATTER / Option to control whether javadoc comments are formatted 1309 * - option id: "org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" 1310 * - possible values: { TRUE, FALSE } 1311 * - default: TRUE 1312 * </pre> 1313 * @see #TRUE 1314 * @see #FALSE 1315 * @since 3.3 1316 */ 1317 public final static String FORMATTER_COMMENT_FORMAT_JAVADOC_COMMENT = "org.eclipse.jdt.core.formatter.comment.format_javadoc_comments"; //$NON-NLS-1$ 1318 1319 /** 1320 * <pre> 1321 * FORMATTER / Option to control whether the header comment of a Java source file is formatted 1322 * - option id: "org.eclipse.jdt.core.formatter.comment.format_header" 1323 * - possible values: { TRUE, FALSE } 1324 * - default: FALSE 1325 * </pre> 1326 * @see #TRUE 1327 * @see #FALSE 1328 * @since 3.1 1329 */ 1330 public final static String FORMATTER_COMMENT_FORMAT_HEADER = "org.eclipse.jdt.core.formatter.comment.format_header"; //$NON-NLS-1$ 1331 1332 /** 1333 * <pre> 1334 * FORMATTER / Option to control whether HTML tags are formatted. 1335 * - option id: "org.eclipse.jdt.core.formatter.comment.format_html" 1336 * - possible values: { TRUE, FALSE } 1337 * - default: TRUE 1338 * </pre> 1339 * @see #TRUE 1340 * @see #FALSE 1341 * @since 3.1 1342 */ 1343 public final static String FORMATTER_COMMENT_FORMAT_HTML = "org.eclipse.jdt.core.formatter.comment.format_html"; //$NON-NLS-1$ 1344 1345 /** 1346 * <pre> 1347 * FORMATTER / Option to control whether code snippets are formatted in comments 1348 * - option id: "org.eclipse.jdt.core.formatter.comment.format_source_code" 1349 * - possible values: { TRUE, FALSE } 1350 * - default: TRUE 1351 * </pre> 1352 * @see #TRUE 1353 * @see #FALSE 1354 * @since 3.1 1355 */ 1356 public final static String FORMATTER_COMMENT_FORMAT_SOURCE = "org.eclipse.jdt.core.formatter.comment.format_source_code"; //$NON-NLS-1$ 1357 1358 /** 1359 * <pre> 1360 * FORMATTER / Option to control whether description of Javadoc parameters are indented 1361 * - option id: "org.eclipse.jdt.core.formatter.comment.indent_parameter_description" 1362 * - possible values: { TRUE, FALSE } 1363 * - default: TRUE 1364 * </pre> 1365 * @see #TRUE 1366 * @see #FALSE 1367 * @see #FORMATTER_COMMENT_INDENT_TAG_DESCRIPTION 1368 * @since 3.1 1369 */ 1370 public static final String FORMATTER_COMMENT_INDENT_PARAMETER_DESCRIPTION = "org.eclipse.jdt.core.formatter.comment.indent_parameter_description"; //$NON-NLS-1$ 1371 /** 1372 * <pre> 1373 * FORMATTER / Option to control whether Javadoc tag descriptions are indented when wrapped, 1374 * excluding tags controlled by #FORMATTER_COMMENT_INDENT_PARAMETER_DESCRIPTION 1375 * - option id: "org.eclipse.jdt.core.formatter.comment.indent_return_description" 1376 * - possible values: { TRUE, FALSE } 1377 * - default: TRUE 1378 * </pre> 1379 * @see #TRUE 1380 * @see #FALSE 1381 * @see #FORMATTER_COMMENT_INDENT_PARAMETER_DESCRIPTION 1382 * @since 3.17 1383 */ 1384 public static final String FORMATTER_COMMENT_INDENT_TAG_DESCRIPTION = "org.eclipse.jdt.core.formatter.comment.indent_tag_description"; //$NON-NLS-1$ 1385 1386 /** 1387 * <pre> 1388 * FORMATTER / Option to control whether Javadoc root tags are indented. 1389 * - option id: "org.eclipse.jdt.core.formatter.comment.indent_root_tags" 1390 * - possible values: { TRUE, FALSE } 1391 * - default: TRUE 1392 * </pre> 1393 * 1394 * Note that at most one of these options can be set to {@code TRUE}: 1395 * <ul> 1396 * <li>{@code FORMATTER_COMMENT_INDENT_ROOT_TAGS}, 1397 * <li>{@code FORMATTER_COMMENT_ALIGN_TAGS_NAMES_DESCRIPTIONS}, 1398 * <li>{@code FORMATTER_COMMENT_ALIGN_TAGS_DESCREIPTIONS_GROUPED}. 1399 * </ul> 1400 * 1401 * @see #TRUE 1402 * @see #FALSE 1403 * @see #FORMATTER_COMMENT_ALIGN_TAGS_NAMES_DESCRIPTIONS 1404 * @see #FORMATTER_COMMENT_ALIGN_TAGS_DESCREIPTIONS_GROUPED 1405 * @since 3.1 1406 */ 1407 public final static String FORMATTER_COMMENT_INDENT_ROOT_TAGS = "org.eclipse.jdt.core.formatter.comment.indent_root_tags"; //$NON-NLS-1$ 1408 1409 /** 1410 * <pre> 1411 * FORMATTER / Option to control whether names and descriptions in Javadoc root tags should be aligned. 1412 * - option id: "org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions" 1413 * - possible values: { TRUE, FALSE } 1414 * - default: TRUE 1415 * </pre> 1416 * 1417 * Note that at most one of these options can be set to {@code TRUE}: 1418 * <ul> 1419 * <li>{@code FORMATTER_COMMENT_INDENT_ROOT_TAGS}, 1420 * <li>{@code FORMATTER_COMMENT_ALIGN_TAGS_NAMES_DESCRIPTIONS}, 1421 * <li>{@code FORMATTER_COMMENT_ALIGN_TAGS_DESCREIPTIONS_GROUPED}. 1422 * </ul> 1423 * 1424 * @see #TRUE 1425 * @see #FALSE 1426 * @see #FORMATTER_COMMENT_INDENT_ROOT_TAGS 1427 * @see #FORMATTER_COMMENT_ALIGN_TAGS_DESCREIPTIONS_GROUPED 1428 * @since 3.14 1429 */ 1430 public static final String FORMATTER_COMMENT_ALIGN_TAGS_NAMES_DESCRIPTIONS = "org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions"; //$NON-NLS-1$ 1431 1432 /** 1433 * <pre> 1434 * FORMATTER / Option to control whether descriptions and names in Javadoc root tags, should be aligned and grouped by tag type. 1435 * - option id: "org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped" 1436 * - possible values: { TRUE, FALSE } 1437 * - default: TRUE 1438 * </pre> 1439 * 1440 * Note that at most one of these options can be set to {@code TRUE}: 1441 * <ul> 1442 * <li>{@code FORMATTER_COMMENT_INDENT_ROOT_TAGS}, 1443 * <li>{@code FORMATTER_COMMENT_ALIGN_TAGS_NAMES_DESCRIPTIONS}, 1444 * <li>{@code FORMATTER_COMMENT_ALIGN_TAGS_DESCREIPTIONS_GROUPED}. 1445 * </ul> 1446 * 1447 * @see #TRUE 1448 * @see #FALSE 1449 * @see #FORMATTER_COMMENT_INDENT_ROOT_TAGS 1450 * @see #FORMATTER_COMMENT_ALIGN_TAGS_NAMES_DESCRIPTIONS 1451 * @since 3.14 1452 */ 1453 public static final String FORMATTER_COMMENT_ALIGN_TAGS_DESCREIPTIONS_GROUPED = "org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped"; //$NON-NLS-1$ 1454 1455 /** 1456 * <pre> 1457 * FORMATTER / Option to insert an empty line before the Javadoc root tag block 1458 * - option id: "org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" 1459 * - possible values: { INSERT, DO_NOT_INSERT } 1460 * - default: INSERT 1461 * </pre> 1462 * @see JavaCore#INSERT 1463 * @see JavaCore#DO_NOT_INSERT 1464 * @since 3.1 1465 */ 1466 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$ 1467 /** 1468 * <pre> 1469 * FORMATTER / Option to insert an empty line between Javadoc tags of different type 1470 * - option id: "org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags" 1471 * - possible values: { INSERT, DO_NOT_INSERT } 1472 * - default: INSERT 1473 * </pre> 1474 * @see JavaCore#INSERT 1475 * @see JavaCore#DO_NOT_INSERT 1476 * @since 3.20 1477 */ 1478 public final static String FORMATTER_COMMENT_INSERT_EMPTY_LINE_BETWEEN_DIFFERENT_TAGS = "org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags"; //$NON-NLS-1$ 1479 1480 /** 1481 * <pre> 1482 * FORMATTER / Option to insert a new line after Javadoc root tag parameters 1483 * - option id: "org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter" 1484 * - possible values: { INSERT, DO_NOT_INSERT } 1485 * - default: INSERT 1486 * </pre> 1487 * @see JavaCore#INSERT 1488 * @see JavaCore#DO_NOT_INSERT 1489 * @since 3.1 1490 */ 1491 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$ 1492 1493 /** 1494 * <pre> 1495 * FORMATTER / Option to specify the line length for comments. 1496 * - option id: "org.eclipse.jdt.core.formatter.comment.line_length" 1497 * - possible values: "<n>", where n is zero or a positive integer 1498 * - default: "80" 1499 * </pre> 1500 * @since 3.1 1501 */ 1502 public final static String FORMATTER_COMMENT_LINE_LENGTH = "org.eclipse.jdt.core.formatter.comment.line_length"; //$NON-NLS-1$ 1503 1504 /** 1505 * <pre> 1506 * FORMATTER / Option to control whether comments' line length will be counted from their starting position 1507 * - option id: "org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position" 1508 * - possible values: { TRUE, FALSE } 1509 * - default: TRUE 1510 * </pre> 1511 * @since 3.13 1512 */ 1513 public final static String FORMATTER_COMMENT_COUNT_LINE_LENGTH_FROM_STARTING_POSITION = "org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position"; //$NON-NLS-1$ 1514 1515 /** 1516 * <pre> 1517 * FORMATTER / Option to control whether block comments will have new lines at boundaries 1518 * - option id: "org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries" 1519 * - possible values: { TRUE, FALSE } 1520 * - default: TRUE 1521 * </pre> 1522 * @see #TRUE 1523 * @see #FALSE 1524 * @since 3.6 1525 */ 1526 public final static String FORMATTER_COMMENT_NEW_LINES_AT_BLOCK_BOUNDARIES = "org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries"; //$NON-NLS-1$ 1527 1528 /** 1529 * <pre> 1530 * FORMATTER / Option to control whether javadoc comments will have new lines at boundaries 1531 * - option id: "org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries" 1532 * - possible values: { TRUE, FALSE } 1533 * - default: TRUE 1534 * </pre> 1535 * @see #TRUE 1536 * @see #FALSE 1537 * @since 3.6 1538 */ 1539 public final static String FORMATTER_COMMENT_NEW_LINES_AT_JAVADOC_BOUNDARIES = "org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries"; //$NON-NLS-1$ 1540 1541 /** 1542 * <pre> 1543 * FORMATTER / Option to compact else/if 1544 * - option id: "org.eclipse.jdt.core.formatter.compact_else_if" 1545 * - possible values: { TRUE, FALSE } 1546 * - default: TRUE 1547 * </pre> 1548 * @see #TRUE 1549 * @see #FALSE 1550 * @since 3.0 1551 */ 1552 public static final String FORMATTER_COMPACT_ELSE_IF = JavaCore.PLUGIN_ID + ".formatter.compact_else_if"; //$NON-NLS-1$ 1553 1554 /** 1555 * <pre> 1556 * FORMATTER / Option to set the continuation indentation 1557 * - option id: "org.eclipse.jdt.core.formatter.continuation_indentation" 1558 * - possible values: "<n>", where n is zero or a positive integer 1559 * - default: "2" 1560 * </pre> 1561 * @since 3.0 1562 */ 1563 public static final String FORMATTER_CONTINUATION_INDENTATION = JavaCore.PLUGIN_ID + ".formatter.continuation_indentation"; //$NON-NLS-1$ 1564 /** 1565 * <pre> 1566 * FORMATTER / Option to set the continuation indentation inside array initializer 1567 * - option id: "org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" 1568 * - possible values: "<n>", where n is zero or a positive integer 1569 * - default: "2" 1570 * </pre> 1571 * @since 3.0 1572 */ 1573 public static final String FORMATTER_CONTINUATION_INDENTATION_FOR_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.continuation_indentation_for_array_initializer"; //$NON-NLS-1$ 1574 /** 1575 * <pre> 1576 * FORMATTER / Option to use the disabling and enabling tags defined respectively by the {@link #FORMATTER_DISABLING_TAG} and the {@link #FORMATTER_ENABLING_TAG} options. 1577 * - option id: "org.eclipse.jdt.core.formatter.use_on_off_tags" 1578 * - possible values: TRUE / FALSE 1579 * - default: FALSE 1580 * </pre> 1581 * @since 3.6 1582 */ 1583 public static final String FORMATTER_USE_ON_OFF_TAGS = JavaCore.PLUGIN_ID + ".formatter.use_on_off_tags"; //$NON-NLS-1$ 1584 /** 1585 * <pre> 1586 * FORMATTER / Option to define the tag to put in a comment to disable the formatting. 1587 * - option id: "org.eclipse.jdt.core.formatter.disabling_tag" 1588 * - possible values: String, with constraints mentioned below 1589 * - default: "@formatter:off" 1590 * 1591 * See the {@link #FORMATTER_ENABLING_TAG} option to re-enable it. 1592 * </pre> 1593 * 1594 * <p> 1595 * Note that: 1596 * <ol> 1597 * <li>This tag is used by the formatter only if the 1598 * {@link #FORMATTER_USE_ON_OFF_TAGS} option is set to {@link #TRUE}.</li> 1599 * <li>The tag name will be trimmed. Hence if it does contain white spaces 1600 * at the beginning or at the end, they will not be taken into account while 1601 * searching for the tag in the comments</li> 1602 * <li>If a tag is starting with a letter or digit, then it cannot be leaded by 1603 * another letter or digit to be recognized 1604 * (<code>"ToDisableFormatter"</code> will not be recognized as a disabling tag 1605 * <code>"DisableFormatter"</code>, but <code>"To:DisableFormatter"</code> 1606 * will be detected for either tag <code>"DisableFormatter"</code> or 1607 * <code>":DisableFormatter"</code>).<br> 1608 * Respectively, a tag ending with a letter or digit cannot be followed by a letter 1609 * or digit to be recognized (<code>"DisableFormatter1"</code> will not be 1610 * recognized as a disabling tag <code>"DisableFormatter"</code>, but 1611 * <code>"DisableFormatter:1"</code> will be detected either for tag 1612 * <code>"DisableFormatter"</code> or <code>"DisableFormatter:"</code>)</li> 1613 * <li>As soon as the formatter encounters the defined disabling tag, it stops to 1614 * format the code from the beginning of the comment including this tag. If it 1615 * was already disabled, the tag has no special effect. 1616 * <p> 1617 * For example, the second default enabling tag "<b>@formatter:off</b>" 1618 * in the following snippet is not necessary as the formatter was already disabled 1619 * since the first one: 1620 * <pre> 1621 * class X { 1622 * // @formatter:off 1623 * void foo1() {} 1624 * // @formatter:off 1625 * void foo2() {} 1626 * void bar1() {} 1627 * void bar2() {} 1628 * } 1629 * </pre> 1630 * </li> 1631 * <li>If no enabling tag is found by the formatter after the disabling tag, then 1632 * the end of the snippet won't be formatted.<br> 1633 * For example, when a disabling tag is put at the beginning of the code, then 1634 * the entire content of a compilation unit is not formatted: 1635 * <pre> 1636 * // @formatter:off 1637 * class X { 1638 * void foo1() {} 1639 * void foo2() {} 1640 * void bar1() {} 1641 * void bar2() {} 1642 * } 1643 * </pre> 1644 * </li> 1645 * <li>If a mix of disabling and enabling tags is done in the same comment, then 1646 * the formatter will only take into account the last encountered tag in the 1647 * comment. 1648 * <p>For example, in the following snippet, the formatter will be disabled after 1649 * the comment:</p> 1650 * <pre> 1651 * class X { 1652 * /* 1653 * * This is a comment with a mix of disabling and enabling tags: 1654 * * - <b>@formatter:off</b> 1655 * * - <b>@formatter:on</b> 1656 * * - <b>@formatter:off</b> 1657 * * The formatter will stop to format from the beginning of this comment... 1658 * */ 1659 * void foo() {} 1660 * void bar() {} 1661 * } 1662 * </pre> 1663 * </li> 1664 * <li>The tag cannot include newline character (i.e. '\n') but it can have white 1665 * spaces.<br> 1666 * E.g. "<b>format: off</b>" is a valid disabling tag.<br> 1667 * In the future, newlines may be used to support multiple disabling tags. 1668 * </li> 1669 * <li>The tag can include line or block comments start/end tokens. 1670 * <p>If such tags are used, e.g. "<b>//J-</b>", then the single comment can 1671 * also stop the formatting as shown in the following snippet:</p> 1672 * <pre> 1673 * //J- 1674 * // Formatting was stopped from comment above... 1675 * public class X { 1676 * //J+ 1677 * // Formatting is restarted from here... 1678 * void foo() {} 1679 * </pre> 1680 * <p>As any disabling tags, as soon as a comment includes it, 1681 * the formatting stops from this comment:</p> 1682 * <pre> 1683 * public class X { 1684 * // Line comment including the disabling tag: //J- 1685 * // Formatting was stopped from comment above... 1686 * void foo1() {} 1687 * //J+ 1688 * // Formatting restarts from here... 1689 * void bar1() {} 1690 * /* 1691 * * Block comment including the disabling tag: //J+ 1692 * * The formatter stops from this comment... 1693 * */ 1694 * void foo2() {} 1695 * //J+ 1696 * // Formatting restarts from here... 1697 * void bar2() {} 1698 * /** 1699 * * Javadoc comment including the enabling tag: //J+ 1700 * * The formatter stops from this comment... 1701 * */ 1702 * void foo3() {} 1703 * } 1704 * </pre> 1705 * </li> 1706 * </ol> 1707 * @since 3.6 1708 */ 1709 public static final String FORMATTER_DISABLING_TAG = JavaCore.PLUGIN_ID + ".formatter.disabling_tag"; //$NON-NLS-1$ 1710 /** 1711 * <pre> 1712 * FORMATTER / Option to define the tag to put in a comment to re-enable the formatting after it has been disabled (see {@link #FORMATTER_DISABLING_TAG}) 1713 * - option id: "org.eclipse.jdt.core.formatter.enabling_tag" 1714 * - possible values: String, with constraints mentioned below 1715 * - default: "@formatter:on" 1716 * </pre> 1717 * 1718 * <p> 1719 * Note that: 1720 * <ol> 1721 * <li>This tag is used by the formatter only if the 1722 * {@link #FORMATTER_USE_ON_OFF_TAGS} option is set to {@link #TRUE}.</li> 1723 * <li>The tag name will be trimmed. Hence if it does contain white spaces 1724 * at the beginning or at the end, they will not be taken into account while 1725 * searching for the tag in the comments</li> 1726 * <li>If a tag is starting with a letter or digit, then it cannot be leaded by 1727 * another letter or digit to be recognized 1728 * (<code>"ReEnableFormatter"</code> will not be recognized as an enabling tag 1729 * <code>"EnableFormatter"</code>, but <code>"Re:EnableFormatter"</code> 1730 * will be detected for either tag <code>"EnableFormatter"</code> or 1731 * <code>":EnableFormatter"</code>).<br> 1732 * Respectively, a tag ending with a letter or digit cannot be followed by a letter 1733 * or digit to be recognized (<code>"EnableFormatter1"</code> will not be 1734 * recognized as an enabling tag <code>"EnableFormatter"</code>, but 1735 * <code>"EnableFormatter:1"</code> will be detected either for tag 1736 * <code>"EnableFormatter"</code> or <code>"EnableFormatter:"</code>)</li> 1737 * <li>As soon as the formatter encounters the defined enabling tag, it re-starts 1738 * to format the code just after the comment including this tag. If it was already 1739 * active, i.e. already re-enabled or never disabled, the tag has no special effect. 1740 * <p> 1741 * For example, the default enabling tag "<b>@formatter:on</b>" 1742 * in the following snippet is not necessary as the formatter has never been 1743 * disabled: 1744 * <pre> 1745 * class X { 1746 * void foo1() {} 1747 * void foo2() {} 1748 * // @formatter:on 1749 * void bar1() {} 1750 * void bar2() {} 1751 * } 1752 * </pre> 1753 * Or, in the following other snippet, the second enabling tag is not necessary as 1754 * the formatting will have been re-enabled by the first one: 1755 * <pre> 1756 * class X { 1757 * // @formatter:off 1758 * void foo1() {} 1759 * void foo2() {} 1760 * // @formatter:on 1761 * void bar1() {} 1762 * // @formatter:on 1763 * void bar2() {} 1764 * } 1765 * </pre> 1766 * </li> 1767 * <li>If a mix of disabling and enabling tags is done in the same comment, then 1768 * the formatter will only take into account the last encountered tag in the 1769 * comment. 1770 * <p>For example, in the following snippet, the formatter will be re-enabled after 1771 * the comment:</p> 1772 * <pre> 1773 * // @formatter:off 1774 * class X { 1775 * /* 1776 * * This is a comment with a mix of disabling and enabling tags: 1777 * * - <b>@formatter:on</b> 1778 * * - <b>@formatter:off</b> 1779 * * - <b>@formatter:on</b> 1780 * * The formatter will restart to format after this comment... 1781 * */ 1782 * void foo() {} 1783 * void bar() {} 1784 * } 1785 * </pre> 1786 * </li> 1787 * <li>The tag cannot include newline character (i.e. '\n') but it can have white 1788 * spaces.<br> 1789 * E.g. "<b>format: on</b>" is a valid enabling tag<br> 1790 * In the future, newlines may be used to support multiple enabling tags. 1791 * </li> 1792 * <li>The tag can include line or block comments start/end tokens. Javadoc 1793 * tokens are not considered as valid tags. 1794 * <p>If such tags are used, e.g. "<b>//J+</b>", then the single comment can 1795 * also start the formatting as shown in the following snippet:</p> 1796 * <pre> 1797 * //J- 1798 * // Formatting was stopped from comment above... 1799 * public class X { 1800 * //J+ 1801 * // Formatting restarts from here... 1802 * void foo() {} 1803 * } 1804 * </pre> 1805 * <p>As any enabling tags, as soon as a comment includes it, 1806 * the formatting restarts just after the comment:</p> 1807 * <pre> 1808 * public class X { 1809 * //J- 1810 * // Formatting was stopped from comment above... 1811 * void foo1() {} 1812 * // Line comment including the enabling tag: //J+ 1813 * // Formatting restarts from here... 1814 * void bar1() {} 1815 * //J- 1816 * // Formatting was stopped from comment above... 1817 * void foo2() {} 1818 * /* 1819 * * Block comment including the enabling tag: //J+ 1820 * * The formatter restarts after this comment... 1821 * */ 1822 * // Formatting restarts from here... 1823 * void bar2() {} 1824 * //J- 1825 * // Formatting was stopped from comment above... 1826 * void foo3() {} 1827 * /** 1828 * * Javadoc comment including the enabling tag: //J+ 1829 * * The formatter restarts after this comment... 1830 * */ 1831 * void bar3() {} 1832 * } 1833 * </pre> 1834 * </li> 1835 * </ol> 1836 * @since 3.6 1837 */ 1838 public static final String FORMATTER_ENABLING_TAG = JavaCore.PLUGIN_ID + ".formatter.enabling_tag"; //$NON-NLS-1$ 1839 /** 1840 * <pre> 1841 * FORMATTER / Option to indent body declarations compare to its enclosing annotation declaration header 1842 * - option id: "org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header" 1843 * - possible values: { TRUE, FALSE } 1844 * - default: TRUE 1845 * </pre> 1846 * @see #TRUE 1847 * @see #FALSE 1848 * @since 3.2 1849 */ 1850 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$ 1851 /** 1852 * <pre> 1853 * FORMATTER / Option to indent body declarations compare to its enclosing enum constant header 1854 * - option id: "org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header" 1855 * - possible values: { TRUE, FALSE } 1856 * - default: TRUE 1857 * </pre> 1858 * @see #TRUE 1859 * @see #FALSE 1860 * @since 3.1 1861 */ 1862 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$ 1863 /** 1864 * <pre> 1865 * FORMATTER / Option to indent body declarations compare to its enclosing enum declaration header 1866 * - option id: "org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header" 1867 * - possible values: { TRUE, FALSE } 1868 * - default: TRUE 1869 * </pre> 1870 * @see #TRUE 1871 * @see #FALSE 1872 * @since 3.1 1873 */ 1874 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$ 1875 /** 1876 * <pre> 1877 * FORMATTER / Option to indent body declarations compare to its enclosing record header 1878 * - option id: "org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_record_header" 1879 * - possible values: { TRUE, FALSE } 1880 * - default: TRUE 1881 * </pre> 1882 * @see #TRUE 1883 * @see #FALSE 1884 * @since 3.22 1885 */ 1886 public static final String FORMATTER_INDENT_BODY_DECLARATIONS_COMPARE_TO_RECORD_HEADER = JavaCore.PLUGIN_ID + ".formatter.indent_body_declarations_compare_to_record_header"; //$NON-NLS-1$ 1887 /** 1888 * <pre> 1889 * FORMATTER / Option to indent body declarations compare to its enclosing type header 1890 * - option id: "org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header" 1891 * - possible values: { TRUE, FALSE } 1892 * - default: TRUE 1893 * </pre> 1894 * @see #TRUE 1895 * @see #FALSE 1896 * @since 3.0 1897 */ 1898 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$ 1899 /** 1900 * <pre> 1901 * FORMATTER / Option to indent breaks compare to cases 1902 * - option id: "org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases" 1903 * - possible values: { TRUE, FALSE } 1904 * - default: TRUE 1905 * </pre> 1906 * @see #TRUE 1907 * @see #FALSE 1908 * @since 3.0 1909 */ 1910 public static final String FORMATTER_INDENT_BREAKS_COMPARE_TO_CASES = JavaCore.PLUGIN_ID + ".formatter.indent_breaks_compare_to_cases"; //$NON-NLS-1$ 1911 /** 1912 * <pre> 1913 * FORMATTER / Option to indent empty lines 1914 * - option id: "org.eclipse.jdt.core.formatter.indent_empty_lines" 1915 * - possible values: { TRUE, FALSE } 1916 * - default: FALSE 1917 * </pre> 1918 * @see #TRUE 1919 * @see #FALSE 1920 * @since 3.2 1921 */ 1922 public static final String FORMATTER_INDENT_EMPTY_LINES = JavaCore.PLUGIN_ID + ".formatter.indent_empty_lines"; //$NON-NLS-1$ 1923 /** 1924 * <pre> 1925 * FORMATTER / Option to indent statements inside a block 1926 * - option id: "org.eclipse.jdt.core.formatter.indent_statements_compare_to_block" 1927 * - possible values: { TRUE, FALSE } 1928 * - default: TRUE 1929 * </pre> 1930 * @see #TRUE 1931 * @see #FALSE 1932 * @since 3.0 1933 */ 1934 public static final String FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BLOCK = JavaCore.PLUGIN_ID + ".formatter.indent_statements_compare_to_block"; //$NON-NLS-1$ 1935 /** 1936 * <pre> 1937 * FORMATTER / Option to indent statements inside the body of a method or a constructor 1938 * - option id: "org.eclipse.jdt.core.formatter.indent_statements_compare_to_body" 1939 * - possible values: { TRUE, FALSE } 1940 * - default: TRUE 1941 * </pre> 1942 * @see #TRUE 1943 * @see #FALSE 1944 * @since 3.0 1945 */ 1946 public static final String FORMATTER_INDENT_STATEMENTS_COMPARE_TO_BODY = JavaCore.PLUGIN_ID + ".formatter.indent_statements_compare_to_body"; //$NON-NLS-1$ 1947 /** 1948 * <pre> 1949 * FORMATTER / Option to indent switch statements compare to cases 1950 * - option id: "org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases" 1951 * - possible values: { TRUE, FALSE } 1952 * - default: TRUE 1953 * </pre> 1954 * @see #TRUE 1955 * @see #FALSE 1956 * @since 3.0 1957 */ 1958 public static final String FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES = JavaCore.PLUGIN_ID + ".formatter.indent_switchstatements_compare_to_cases"; //$NON-NLS-1$ 1959 /** 1960 * <pre> 1961 * FORMATTER / Option to indent switch statements compare to switch 1962 * - option id: "org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch" 1963 * - possible values: { TRUE, FALSE } 1964 * - default: TRUE 1965 * </pre> 1966 * @see #TRUE 1967 * @see #FALSE 1968 * @since 3.0 1969 */ 1970 public static final String FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH = JavaCore.PLUGIN_ID + ".formatter.indent_switchstatements_compare_to_switch"; //$NON-NLS-1$ 1971 1972 /** 1973 * <pre> 1974 * FORMATTER / Option to specify the equivalent number of spaces that represents one indentation 1975 * - option id: "org.eclipse.jdt.core.formatter.indentation.size" 1976 * - possible values: "<n>", where n is zero or a positive integer 1977 * - default: "4" 1978 * </pre> 1979 * <p>This option is used only if the tab char is set to MIXED. 1980 * </p> 1981 * @see #FORMATTER_TAB_CHAR 1982 * @since 3.1 1983 */ 1984 public static final String FORMATTER_INDENTATION_SIZE = JavaCore.PLUGIN_ID + ".formatter.indentation.size"; //$NON-NLS-1$ 1985 1986 /** 1987 * <pre> 1988 * FORMATTER / Option to specify how text blocks are indented 1989 * - option id: "org.eclipse.jdt.core.formatter.text_block_indentation" 1990 * - possible values: { INDENT_PRESERVE, INDENT_BY_ONE, INDENT_DEFAULT, INDENT_ON_COLUMN } 1991 * - default: INDENT_DEFAULT 1992 * </pre> 1993 * @see #INDENT_PRESERVE 1994 * @see #INDENT_BY_ONE 1995 * @see #INDENT_DEFAULT 1996 * @see #INDENT_ON_COLUMN 1997 * @since 3.20 1998 */ 1999 public static final String FORMATTER_TEXT_BLOCK_INDENTATION = JavaCore.PLUGIN_ID + ".formatter.text_block_indentation"; //$NON-NLS-1$ 2000 2001 /** 2002 * <pre> 2003 * FORMATTER / Option to insert a new line after an annotation 2004 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_annotation" 2005 * - possible values: { INSERT, DO_NOT_INSERT } 2006 * - default: INSERT 2007 * </pre> 2008 * @see JavaCore#INSERT 2009 * @see JavaCore#DO_NOT_INSERT 2010 * @since 3.1 2011 * @deprecated 2012 * All new options must be enabled to activate old strategy 2013 * {@link #FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_MEMBER} 2014 * {@link #FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_LOCAL_VARIABLE} 2015 * {@link #FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_PARAMETER} 2016 */ 2017 @Deprecated 2018 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_annotation";//$NON-NLS-1$ 2019 2020 /** 2021 * <pre> 2022 * FORMATTER / Option to insert a new line after an annotation on a member (package, class, method, field declaration) 2023 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member" 2024 * - possible values: { INSERT, DO_NOT_INSERT } 2025 * - default: INSERT 2026 * </pre> 2027 * @see JavaCore#INSERT 2028 * @see JavaCore#DO_NOT_INSERT 2029 * @since 3.4 2030 * @deprecated 2031 * All new options must be enabled to activate old strategy 2032 * {@link #FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_FIELD} 2033 * {@link #FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_METHOD} 2034 * {@link #FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_PACKAGE} 2035 * {@link #FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_TYPE} 2036 */ 2037 @Deprecated 2038 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_MEMBER = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_annotation_on_member";//$NON-NLS-1$ 2039 2040 /** 2041 * <pre> 2042 * FORMATTER / Option to insert a new line after an annotation on an enum constant declaration 2043 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant" 2044 * - possible values: { INSERT, DO_NOT_INSERT } 2045 * - default: INSERT 2046 * </pre> 2047 * @see JavaCore#INSERT 2048 * @see JavaCore#DO_NOT_INSERT 2049 * @since 3.12 2050 */ 2051 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_ENUM_CONSTANT = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_annotation_on_enum_constant";//$NON-NLS-1$ 2052 2053 /** 2054 * <pre> 2055 * FORMATTER / Option to insert a new line after an annotation on a field declaration 2056 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field" 2057 * - possible values: { INSERT, DO_NOT_INSERT } 2058 * - default: INSERT 2059 * </pre> 2060 * @see JavaCore#INSERT 2061 * @see JavaCore#DO_NOT_INSERT 2062 * @since 3.7 2063 */ 2064 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_FIELD = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_annotation_on_field";//$NON-NLS-1$ 2065 2066 /** 2067 * <pre> 2068 * FORMATTER / Option to insert a new line after an annotation on a method declaration 2069 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method" 2070 * - possible values: { INSERT, DO_NOT_INSERT } 2071 * - default: INSERT 2072 * </pre> 2073 * @see JavaCore#INSERT 2074 * @see JavaCore#DO_NOT_INSERT 2075 * @since 3.7 2076 */ 2077 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_METHOD = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_annotation_on_method";//$NON-NLS-1$ 2078 2079 /** 2080 * <pre> 2081 * FORMATTER / Option to insert a new line after an annotation on a package declaration 2082 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package" 2083 * - possible values: { INSERT, DO_NOT_INSERT } 2084 * - default: INSERT 2085 * </pre> 2086 * @see JavaCore#INSERT 2087 * @see JavaCore#DO_NOT_INSERT 2088 * @since 3.7 2089 */ 2090 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_PACKAGE = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_annotation_on_package";//$NON-NLS-1$ 2091 2092 /** 2093 * <pre> 2094 * FORMATTER / Option to insert a new line after an annotation on a type declaration 2095 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type" 2096 * - possible values: { INSERT, DO_NOT_INSERT } 2097 * - default: INSERT 2098 * </pre> 2099 * @see JavaCore#INSERT 2100 * @see JavaCore#DO_NOT_INSERT 2101 * @since 3.7 2102 */ 2103 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_TYPE = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_annotation_on_type";//$NON-NLS-1$ 2104 2105 /** 2106 * <pre> 2107 * FORMATTER / Option to insert a new line after a type annotation 2108 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation" 2109 * - possible values: { INSERT, DO_NOT_INSERT } 2110 * - default: DO_NOT_INSERT 2111 * </pre> 2112 * @see JavaCore#INSERT 2113 * @see JavaCore#DO_NOT_INSERT 2114 * @since 3.10 2115 */ 2116 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_TYPE_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_type_annotation";//$NON-NLS-1$ 2117 /** 2118 * <pre> 2119 * FORMATTER / Option to insert a new line after an annotation on a parameter 2120 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter" 2121 * - possible values: { INSERT, DO_NOT_INSERT } 2122 * - default: DO_NOT_INSERT 2123 * </pre> 2124 * @see JavaCore#INSERT 2125 * @see JavaCore#DO_NOT_INSERT 2126 * @since 3.4 2127 */ 2128 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_PARAMETER = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_annotation_on_parameter";//$NON-NLS-1$ 2129 2130 /** 2131 * <pre> 2132 * FORMATTER / Option to insert a new line after an annotation on a local variable 2133 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable" 2134 * - possible values: { INSERT, DO_NOT_INSERT } 2135 * - default: INSERT 2136 * </pre> 2137 * @see JavaCore#INSERT 2138 * @see JavaCore#DO_NOT_INSERT 2139 * @since 3.4 2140 */ 2141 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_ANNOTATION_ON_LOCAL_VARIABLE = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_annotation_on_local_variable";//$NON-NLS-1$ 2142 2143 /** 2144 * <pre> 2145 * FORMATTER / Option to insert a new line after a label 2146 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_label" 2147 * - possible values: { INSERT, DO_NOT_INSERT } 2148 * - default: DO_NOT_INSERT 2149 * </pre> 2150 * @see JavaCore#INSERT 2151 * @see JavaCore#DO_NOT_INSERT 2152 * @since 3.6 2153 */ 2154 public static final String FORMATTER_INSERT_NEW_LINE_AFTER_LABEL = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_label"; //$NON-NLS-1$ 2155 2156 /** 2157 * <pre> 2158 * FORMATTER / Option to insert a new line after the opening brace in an array initializer 2159 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" 2160 * - possible values: { INSERT, DO_NOT_INSERT } 2161 * - default: DO_NOT_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_NEW_LINE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_after_opening_brace_in_array_initializer";//$NON-NLS-1$ 2168 2169 /** 2170 * <pre> 2171 * FORMATTER / Option to insert a new line at the end of the current file if missing 2172 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing" 2173 * - possible values: { INSERT, DO_NOT_INSERT } 2174 * - default: DO_NOT_INSERT 2175 * </pre> 2176 * @see JavaCore#INSERT 2177 * @see JavaCore#DO_NOT_INSERT 2178 * @since 3.1 2179 */ 2180 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$ 2181 /** 2182 * <pre> 2183 * FORMATTER / Option to insert a new line before the catch keyword in try statement 2184 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement" 2185 * - possible values: { INSERT, DO_NOT_INSERT } 2186 * - default: DO_NOT_INSERT 2187 * </pre> 2188 * @see JavaCore#INSERT 2189 * @see JavaCore#DO_NOT_INSERT 2190 * @since 3.0 2191 */ 2192 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$ 2193 /** 2194 * <pre> 2195 * FORMATTER / Option to insert a new line before the closing brace in an array initializer 2196 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" 2197 * - possible values: { INSERT, DO_NOT_INSERT } 2198 * - default: DO_NOT_INSERT 2199 * </pre> 2200 * @see JavaCore#INSERT 2201 * @see JavaCore#DO_NOT_INSERT 2202 * @since 3.0 2203 */ 2204 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$ 2205 /** 2206 * <pre> 2207 * FORMATTER / Option to insert a new line before the else keyword in if statement 2208 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement" 2209 * - possible values: { INSERT, DO_NOT_INSERT } 2210 * - default: DO_NOT_INSERT 2211 * </pre> 2212 * @see JavaCore#INSERT 2213 * @see JavaCore#DO_NOT_INSERT 2214 * @since 3.0 2215 */ 2216 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$ 2217 /** 2218 * <pre> 2219 * FORMATTER / Option to insert a new line before the finally keyword in try statement 2220 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement" 2221 * - possible values: { INSERT, DO_NOT_INSERT } 2222 * - default: DO_NOT_INSERT 2223 * </pre> 2224 * @see JavaCore#INSERT 2225 * @see JavaCore#DO_NOT_INSERT 2226 * @since 3.0 2227 */ 2228 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$ 2229 /** 2230 * <pre> 2231 * FORMATTER / Option to insert a new line before while in do statement 2232 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement" 2233 * - possible values: { INSERT, DO_NOT_INSERT } 2234 * - default: DO_NOT_INSERT 2235 * </pre> 2236 * @see JavaCore#INSERT 2237 * @see JavaCore#DO_NOT_INSERT 2238 * @since 3.0 2239 */ 2240 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$ 2241 /** 2242 * <pre> 2243 * FORMATTER / Option to insert a new line in an empty annotation declaration 2244 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration" 2245 * - possible values: { INSERT, DO_NOT_INSERT } 2246 * - default: INSERT 2247 * </pre> 2248 * @see JavaCore#INSERT 2249 * @see JavaCore#DO_NOT_INSERT 2250 * @since 3.2 2251 * @deprecated Use {@link #FORMATTER_KEEP_ANNOTATION_DECLARATION_ON_ONE_LINE} instead. 2252 */ 2253 @Deprecated 2254 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$ 2255 /** 2256 * <pre> 2257 * FORMATTER / Option to insert a new line in an empty anonymous type declaration 2258 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration" 2259 * - possible values: { INSERT, DO_NOT_INSERT } 2260 * - default: INSERT 2261 * </pre> 2262 * @see JavaCore#INSERT 2263 * @see JavaCore#DO_NOT_INSERT 2264 * @since 3.0 2265 * @deprecated Use {@link #FORMATTER_KEEP_ANONYMOUS_TYPE_DECLARATION_ON_ONE_LINE} instead. 2266 */ 2267 @Deprecated 2268 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$ 2269 /** 2270 * <pre> 2271 * FORMATTER / Option to insert a new line in an empty block 2272 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block" 2273 * - possible values: { INSERT, DO_NOT_INSERT } 2274 * - default: INSERT 2275 * </pre> 2276 * @see JavaCore#INSERT 2277 * @see JavaCore#DO_NOT_INSERT 2278 * @since 3.0 2279 * @deprecated Use {@link #FORMATTER_KEEP_IF_THEN_BODY_BLOCK_ON_ONE_LINE}, 2280 * {@link #FORMATTER_KEEP_LOOP_BODY_BLOCK_ON_ONE_LINE}, 2281 * {@link #FORMATTER_KEEP_CODE_BLOCK_ON_ONE_LINE}, and 2282 * {@link #FORMATTER_KEEP_LAMBDA_BODY_BLOCK_ON_ONE_LINE} instead. 2283 */ 2284 @Deprecated 2285 public static final String FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK = JavaCore.PLUGIN_ID + ".formatter.insert_new_line_in_empty_block"; //$NON-NLS-1$ 2286 /** 2287 * <pre> 2288 * FORMATTER / Option to insert a new line in an empty enum constant 2289 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant" 2290 * - possible values: { INSERT, DO_NOT_INSERT } 2291 * - default: INSERT 2292 * </pre> 2293 * @see JavaCore#INSERT 2294 * @see JavaCore#DO_NOT_INSERT 2295 * @since 3.1 2296 * @deprecated Use {@link #FORMATTER_KEEP_ENUM_CONSTANT_DECLARATION_ON_ONE_LINE} instead. 2297 */ 2298 @Deprecated 2299 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$ 2300 /** 2301 * <pre> 2302 * FORMATTER / Option to insert a new line in an empty enum declaration 2303 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration" 2304 * - possible values: { INSERT, DO_NOT_INSERT } 2305 * - default: INSERT 2306 * </pre> 2307 * @see JavaCore#INSERT 2308 * @see JavaCore#DO_NOT_INSERT 2309 * @since 3.1 2310 * @deprecated Use {@link #FORMATTER_KEEP_ENUM_DECLARATION_ON_ONE_LINE} instead. 2311 */ 2312 @Deprecated 2313 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$ 2314 /** 2315 * <pre> 2316 * FORMATTER / Option to insert a new line in an empty method body 2317 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body" 2318 * - possible values: { INSERT, DO_NOT_INSERT } 2319 * - default: INSERT 2320 * </pre> 2321 * @see JavaCore#INSERT 2322 * @see JavaCore#DO_NOT_INSERT 2323 * @since 3.0 2324 * @deprecated Use {@link #FORMATTER_KEEP_METHOD_BODY_ON_ONE_LINE} instead. 2325 */ 2326 @Deprecated 2327 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$ 2328 /** 2329 * <pre> 2330 * FORMATTER / Option to insert a new line in an empty type declaration 2331 * - option id: "org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration" 2332 * - possible values: { INSERT, DO_NOT_INSERT } 2333 * - default: INSERT 2334 * </pre> 2335 * @see JavaCore#INSERT 2336 * @see JavaCore#DO_NOT_INSERT 2337 * @since 3.0 2338 * @deprecated Use {@link #FORMATTER_KEEP_TYPE_DECLARATION_ON_ONE_LINE} instead. 2339 */ 2340 @Deprecated 2341 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$ 2342 2343 /** 2344 * <pre> 2345 * FORMATTER / Option to insert a space after and in wilcard 2346 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter" 2347 * - possible values: { INSERT, DO_NOT_INSERT } 2348 * - default: INSERT 2349 * </pre> 2350 * @see JavaCore#INSERT 2351 * @see JavaCore#DO_NOT_INSERT 2352 * @since 3.1 2353 */ 2354 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$ 2355 /** 2356 * <pre> 2357 * FORMATTER / Option to insert a space after arrow in switch case 2358 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case" 2359 * - possible values: { INSERT, DO_NOT_INSERT } 2360 * - default: INSERT 2361 * </pre> 2362 * @see JavaCore#INSERT 2363 * @see JavaCore#DO_NOT_INSERT 2364 * @since 3.18 2365 */ 2366 public static final String FORMATTER_INSERT_SPACE_AFTER_ARROW_IN_SWITCH_CASE = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_arrow_in_switch_case"; //$NON-NLS-1$ 2367 /** 2368 * <pre> 2369 * FORMATTER / Option to insert a space after arrow in switch default 2370 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_default" 2371 * - possible values: { INSERT, DO_NOT_INSERT } 2372 * - default: INSERT 2373 * </pre> 2374 * @see JavaCore#INSERT 2375 * @see JavaCore#DO_NOT_INSERT 2376 * @since 3.18 2377 */ 2378 public static final String FORMATTER_INSERT_SPACE_AFTER_ARROW_IN_SWITCH_DEFAULT = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_arrow_in_switch_default"; //$NON-NLS-1$ 2379 /** 2380 * <pre> 2381 * FORMATTER / Option to insert a space after an assignment operator 2382 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator" 2383 * - possible values: { INSERT, DO_NOT_INSERT } 2384 * - default: INSERT 2385 * </pre> 2386 * @see JavaCore#INSERT 2387 * @see JavaCore#DO_NOT_INSERT 2388 * @since 3.0 2389 */ 2390 public static final String FORMATTER_INSERT_SPACE_AFTER_ASSIGNMENT_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_assignment_operator"; //$NON-NLS-1$ 2391 /** 2392 * <pre> 2393 * FORMATTER / Option to insert a space after at in annotation 2394 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation" 2395 * - possible values: { INSERT, DO_NOT_INSERT } 2396 * - default: INSERT 2397 * </pre> 2398 * @see JavaCore#INSERT 2399 * @see JavaCore#DO_NOT_INSERT 2400 * @since 3.1 2401 */ 2402 public static final String FORMATTER_INSERT_SPACE_AFTER_AT_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_at_in_annotation"; //$NON-NLS-1$ 2403 /** 2404 * <pre> 2405 * FORMATTER / Option to insert a space after at in annotation type declaration 2406 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration" 2407 * - possible values: { INSERT, DO_NOT_INSERT } 2408 * - default: DO_NOT_INSERT 2409 * </pre> 2410 * @see JavaCore#INSERT 2411 * @see JavaCore#DO_NOT_INSERT 2412 * @since 3.1 2413 */ 2414 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$ 2415 /** 2416 * <pre> 2417 * FORMATTER / Option to insert a space after a binary operator 2418 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_binary_operator" 2419 * - possible values: { INSERT, DO_NOT_INSERT } 2420 * - default: INSERT 2421 * </pre> 2422 * @see JavaCore#INSERT 2423 * @see JavaCore#DO_NOT_INSERT 2424 * @since 3.0 2425 * @deprecated Use the new settings instead: {@link #FORMATTER_INSERT_SPACE_AFTER_MULTIPLICATIVE_OPERATOR}, 2426 * {@link #FORMATTER_INSERT_SPACE_AFTER_ADDITIVE_OPERATOR}, {@link #FORMATTER_INSERT_SPACE_AFTER_STRING_CONCATENATION}, 2427 * {@link #FORMATTER_INSERT_SPACE_AFTER_SHIFT_OPERATOR}, {@link #FORMATTER_INSERT_SPACE_AFTER_RELATIONAL_OPERATOR}, 2428 * {@link #FORMATTER_INSERT_SPACE_AFTER_BITWISE_OPERATOR}, {@link #FORMATTER_INSERT_SPACE_AFTER_LOGICAL_OPERATOR} 2429 */ 2430 public static final String FORMATTER_INSERT_SPACE_AFTER_BINARY_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_binary_operator"; //$NON-NLS-1$ 2431 /** 2432 * <pre> 2433 * FORMATTER / Option to insert a space after a multiplicative operator (*, /, %) 2434 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator" 2435 * - possible values: { INSERT, DO_NOT_INSERT } 2436 * - default: INSERT 2437 * </pre> 2438 * @see JavaCore#INSERT 2439 * @see JavaCore#DO_NOT_INSERT 2440 * @since 3.17 2441 */ 2442 public static final String FORMATTER_INSERT_SPACE_AFTER_MULTIPLICATIVE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_multiplicative_operator"; //$NON-NLS-1$ 2443 /** 2444 * <pre> 2445 * FORMATTER / Option to insert a space after an additive operator (+, -) 2446 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_additive_operator" 2447 * - possible values: { INSERT, DO_NOT_INSERT } 2448 * - default: INSERT 2449 * </pre> 2450 * @see JavaCore#INSERT 2451 * @see JavaCore#DO_NOT_INSERT 2452 * @since 3.17 2453 */ 2454 public static final String FORMATTER_INSERT_SPACE_AFTER_ADDITIVE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_additive_operator"; //$NON-NLS-1$ 2455 /** 2456 * <pre> 2457 * FORMATTER / Option to insert a space after a string concatenation operator 2458 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation" 2459 * - possible values: { INSERT, DO_NOT_INSERT } 2460 * - default: INSERT 2461 * </pre> 2462 * @see JavaCore#INSERT 2463 * @see JavaCore#DO_NOT_INSERT 2464 * @since 3.17 2465 */ 2466 public static final String FORMATTER_INSERT_SPACE_AFTER_STRING_CONCATENATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_string_concatenation"; //$NON-NLS-1$ 2467 /** 2468 * <pre> 2469 * FORMATTER / Option to insert a space after a shift operator (<<, >>, >>>) 2470 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_shift_operator" 2471 * - possible values: { INSERT, DO_NOT_INSERT } 2472 * - default: INSERT 2473 * </pre> 2474 * @see JavaCore#INSERT 2475 * @see JavaCore#DO_NOT_INSERT 2476 * @since 3.17 2477 */ 2478 public static final String FORMATTER_INSERT_SPACE_AFTER_SHIFT_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_shift_operator"; //$NON-NLS-1$ 2479 /** 2480 * <pre> 2481 * FORMATTER / Option to insert a space after a relational operator (<, >, <=, >=, ==, !=) 2482 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_relational_operator" 2483 * - possible values: { INSERT, DO_NOT_INSERT } 2484 * - default: INSERT 2485 * </pre> 2486 * @see JavaCore#INSERT 2487 * @see JavaCore#DO_NOT_INSERT 2488 * @since 3.17 2489 */ 2490 public static final String FORMATTER_INSERT_SPACE_AFTER_RELATIONAL_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_relational_operator"; //$NON-NLS-1$ 2491 /** 2492 * <pre> 2493 * FORMATTER / Option to insert a space after a bitwise operator (&, ^, |) 2494 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator" 2495 * - possible values: { INSERT, DO_NOT_INSERT } 2496 * - default: INSERT 2497 * </pre> 2498 * @see JavaCore#INSERT 2499 * @see JavaCore#DO_NOT_INSERT 2500 * @since 3.17 2501 */ 2502 public static final String FORMATTER_INSERT_SPACE_AFTER_BITWISE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_bitwise_operator"; //$NON-NLS-1$ 2503 /** 2504 * <pre> 2505 * FORMATTER / Option to insert a space after a logical operator (&&, ||) 2506 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_logical_operator" 2507 * - possible values: { INSERT, DO_NOT_INSERT } 2508 * - default: INSERT 2509 * </pre> 2510 * @see JavaCore#INSERT 2511 * @see JavaCore#DO_NOT_INSERT 2512 * @since 3.17 2513 */ 2514 public static final String FORMATTER_INSERT_SPACE_AFTER_LOGICAL_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_logical_operator"; //$NON-NLS-1$ 2515 /** 2516 * <pre> 2517 * FORMATTER / Option to insert a space after the closing angle bracket in explicit type arguments on method/constructor invocations 2518 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments" 2519 * - possible values: { INSERT, DO_NOT_INSERT } 2520 * - default: DO_NOT_INSERT 2521 * </pre> 2522 * @see JavaCore#INSERT 2523 * @see JavaCore#DO_NOT_INSERT 2524 * @since 3.1 2525 */ 2526 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$ 2527 /** 2528 * <pre> 2529 * FORMATTER / Option to insert a space after the closing angle bracket in type parameter declarations 2530 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters" 2531 * - possible values: { INSERT, DO_NOT_INSERT } 2532 * - default: INSERT 2533 * </pre> 2534 * @see JavaCore#INSERT 2535 * @see JavaCore#DO_NOT_INSERT 2536 * @since 3.1 2537 */ 2538 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$ 2539 /** 2540 * <pre> 2541 * FORMATTER / Option to insert a space after the closing brace of a block 2542 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" 2543 * - possible values: { INSERT, DO_NOT_INSERT } 2544 * - default: INSERT 2545 * </pre> 2546 * @see JavaCore#INSERT 2547 * @see JavaCore#DO_NOT_INSERT 2548 * @since 3.0 2549 */ 2550 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$ 2551 /** 2552 * <pre> 2553 * FORMATTER / Option to insert a space after the closing parenthesis of a cast expression 2554 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast" 2555 * - possible values: { INSERT, DO_NOT_INSERT } 2556 * - default: INSERT 2557 * </pre> 2558 * @see JavaCore#INSERT 2559 * @see JavaCore#DO_NOT_INSERT 2560 * @since 3.0 2561 */ 2562 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$ 2563 /** 2564 * <pre> 2565 * FORMATTER / Option to insert a space after the colon in an assert statement 2566 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert" 2567 * - possible values: { INSERT, DO_NOT_INSERT } 2568 * - default: INSERT 2569 * </pre> 2570 * @see JavaCore#INSERT 2571 * @see JavaCore#DO_NOT_INSERT 2572 * @since 3.0 2573 */ 2574 public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_ASSERT = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_colon_in_assert"; //$NON-NLS-1$ 2575 /** 2576 * <pre> 2577 * FORMATTER / Option to insert a space after colon in a case statement when a opening brace follows the colon 2578 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case" 2579 * - possible values: { INSERT, DO_NOT_INSERT } 2580 * - default: INSERT 2581 * </pre> 2582 * @see JavaCore#INSERT 2583 * @see JavaCore#DO_NOT_INSERT 2584 * @since 3.0 2585 */ 2586 public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CASE = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_colon_in_case"; //$NON-NLS-1$ 2587 /** 2588 * <pre> 2589 * FORMATTER / Option to insert a space after the colon in a conditional expression 2590 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional" 2591 * - possible values: { INSERT, DO_NOT_INSERT } 2592 * - default: INSERT 2593 * </pre> 2594 * @see JavaCore#INSERT 2595 * @see JavaCore#DO_NOT_INSERT 2596 * @since 3.0 2597 */ 2598 public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_CONDITIONAL = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_colon_in_conditional"; //$NON-NLS-1$ 2599 /** 2600 * <pre> 2601 * FORMATTER / Option to insert a space after colon in a for statement 2602 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for" 2603 * - possible values: { INSERT, DO_NOT_INSERT } 2604 * - default: INSERT 2605 * </pre> 2606 * @see JavaCore#INSERT 2607 * @see JavaCore#DO_NOT_INSERT 2608 * @since 3.1 2609 */ 2610 public static final String FORMATTER_INSERT_SPACE_AFTER_COLON_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_colon_in_for"; //$NON-NLS-1$ 2611 /** 2612 * <pre> 2613 * FORMATTER / Option to insert a space after the colon in a labeled statement 2614 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement" 2615 * - possible values: { INSERT, DO_NOT_INSERT } 2616 * - default: INSERT 2617 * </pre> 2618 * @see JavaCore#INSERT 2619 * @see JavaCore#DO_NOT_INSERT 2620 * @since 3.0 2621 */ 2622 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$ 2623 /** 2624 * <pre> 2625 * FORMATTER / Option to insert a space after the comma in an allocation expression 2626 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" 2627 * - possible values: { INSERT, DO_NOT_INSERT } 2628 * - default: INSERT 2629 * </pre> 2630 * @see JavaCore#INSERT 2631 * @see JavaCore#DO_NOT_INSERT 2632 * @since 3.0 2633 */ 2634 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$ 2635 /** 2636 * <pre> 2637 * FORMATTER / Option to insert a space after the comma in annotation 2638 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation" 2639 * - possible values: { INSERT, DO_NOT_INSERT } 2640 * - default: INSERT 2641 * </pre> 2642 * @see JavaCore#INSERT 2643 * @see JavaCore#DO_NOT_INSERT 2644 * @since 3.1 2645 */ 2646 public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_annotation"; //$NON-NLS-1$ 2647 /** 2648 * <pre> 2649 * FORMATTER / Option to insert a space after the comma in an array initializer 2650 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer" 2651 * - possible values: { INSERT, DO_NOT_INSERT } 2652 * - default: INSERT 2653 * </pre> 2654 * @see JavaCore#INSERT 2655 * @see JavaCore#DO_NOT_INSERT 2656 * @since 3.0 2657 */ 2658 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$ 2659 /** 2660 * <pre> 2661 * FORMATTER / Option to insert a space after the comma in the parameters of a constructor declaration 2662 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters" 2663 * - possible values: { INSERT, DO_NOT_INSERT } 2664 * - default: INSERT 2665 * </pre> 2666 * @see JavaCore#INSERT 2667 * @see JavaCore#DO_NOT_INSERT 2668 * @since 3.0 2669 */ 2670 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$ 2671 /** 2672 * <pre> 2673 * FORMATTER / Option to insert a space after the comma in the exception names in a throws clause of a constructor declaration 2674 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws" 2675 * - possible values: { INSERT, DO_NOT_INSERT } 2676 * - default: INSERT 2677 * </pre> 2678 * @see JavaCore#INSERT 2679 * @see JavaCore#DO_NOT_INSERT 2680 * @since 3.0 2681 */ 2682 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$ 2683 /** 2684 * <pre> 2685 * FORMATTER / Option to insert a space after the comma in the arguments of an enum constant 2686 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments" 2687 * - possible values: { INSERT, DO_NOT_INSERT } 2688 * - default: INSERT 2689 * </pre> 2690 * @see JavaCore#INSERT 2691 * @see JavaCore#DO_NOT_INSERT 2692 * @since 3.1 2693 */ 2694 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$ 2695 /** 2696 * <pre> 2697 * FORMATTER / Option to insert a space after the comma in enum declarations 2698 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations" 2699 * - possible values: { INSERT, DO_NOT_INSERT } 2700 * - default: INSERT 2701 * </pre> 2702 * @see JavaCore#INSERT 2703 * @see JavaCore#DO_NOT_INSERT 2704 * @since 3.1 2705 */ 2706 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$ 2707 /** 2708 * <pre> 2709 * FORMATTER / Option to insert a space after the comma in the arguments of an explicit constructor call 2710 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments" 2711 * - possible values: { INSERT, DO_NOT_INSERT } 2712 * - default: INSERT 2713 * </pre> 2714 * @see JavaCore#INSERT 2715 * @see JavaCore#DO_NOT_INSERT 2716 * @since 3.0 2717 */ 2718 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$ 2719 /** 2720 * <pre> 2721 * FORMATTER / Option to insert a space after the comma in the increments of a for statement 2722 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments" 2723 * - possible values: { INSERT, DO_NOT_INSERT } 2724 * - default: INSERT 2725 * </pre> 2726 * @see JavaCore#INSERT 2727 * @see JavaCore#DO_NOT_INSERT 2728 * @since 3.0 2729 */ 2730 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$ 2731 /** 2732 * <pre> 2733 * FORMATTER / Option to insert a space after the comma in the initializations of a for statement 2734 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits" 2735 * - possible values: { INSERT, DO_NOT_INSERT } 2736 * - default: INSERT 2737 * </pre> 2738 * @see JavaCore#INSERT 2739 * @see JavaCore#DO_NOT_INSERT 2740 * @since 3.0 2741 */ 2742 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$ 2743 /** 2744 * <pre> 2745 * FORMATTER / Option to insert a space after the comma in the parameters of a method declaration 2746 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" 2747 * - possible values: { INSERT, DO_NOT_INSERT } 2748 * - default: INSERT 2749 * </pre> 2750 * @see JavaCore#INSERT 2751 * @see JavaCore#DO_NOT_INSERT 2752 * @since 3.0 2753 */ 2754 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$ 2755 /** 2756 * <pre> 2757 * FORMATTER / Option to insert a space after the comma in the exception names in a throws clause of a method declaration 2758 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws" 2759 * - possible values: { INSERT, DO_NOT_INSERT } 2760 * - default: INSERT 2761 * </pre> 2762 * @see JavaCore#INSERT 2763 * @see JavaCore#DO_NOT_INSERT 2764 * @since 3.0 2765 */ 2766 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$ 2767 /** 2768 * <pre> 2769 * FORMATTER / Option to insert a space after the comma in the arguments of a method invocation 2770 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" 2771 * - possible values: { INSERT, DO_NOT_INSERT } 2772 * - default: INSERT 2773 * </pre> 2774 * @see JavaCore#INSERT 2775 * @see JavaCore#DO_NOT_INSERT 2776 * @since 3.0 2777 */ 2778 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$ 2779 /** 2780 * <pre> 2781 * FORMATTER / Option to insert a space after the comma in multiple field declaration 2782 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations" 2783 * - possible values: { INSERT, DO_NOT_INSERT } 2784 * - default: INSERT 2785 * </pre> 2786 * @see JavaCore#INSERT 2787 * @see JavaCore#DO_NOT_INSERT 2788 * @since 3.0 2789 */ 2790 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$ 2791 /** 2792 * <pre> 2793 * FORMATTER / Option to insert a space after the comma in multiple local declaration 2794 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations" 2795 * - possible values: { INSERT, DO_NOT_INSERT } 2796 * - default: INSERT 2797 * </pre> 2798 * @see JavaCore#INSERT 2799 * @see JavaCore#DO_NOT_INSERT 2800 * @since 3.0 2801 */ 2802 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$ 2803 /** 2804 * <pre> 2805 * FORMATTER / Option to insert a space after the comma in parameterized type reference 2806 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference" 2807 * - possible values: { INSERT, DO_NOT_INSERT } 2808 * - default: INSERT 2809 * </pre> 2810 * @see JavaCore#INSERT 2811 * @see JavaCore#DO_NOT_INSERT 2812 * @since 3.1 2813 */ 2814 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$ 2815 /** 2816 * <pre> 2817 * FORMATTER / Option to insert a space after comma in record components list 2818 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_record_components" 2819 * - possible values: { INSERT, DO_NOT_INSERT } 2820 * - default: INSERT 2821 * </pre> 2822 * @see JavaCore#INSERT 2823 * @see JavaCore#DO_NOT_INSERT 2824 * @since 3.22 2825 */ 2826 public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_RECORD_COMPONENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_record_components"; //$NON-NLS-1$ 2827 /** 2828 * <pre> 2829 * FORMATTER / Option to insert a space after the comma in superinterfaces names of a type header 2830 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces" 2831 * - possible values: { INSERT, DO_NOT_INSERT } 2832 * - default: INSERT 2833 * </pre> 2834 * @see JavaCore#INSERT 2835 * @see JavaCore#DO_NOT_INSERT 2836 * @since 3.0 2837 */ 2838 public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_SUPERINTERFACES = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_superinterfaces"; //$NON-NLS-1$ 2839 /** 2840 * <pre> 2841 * FORMATTER / Option to insert a space after the comma in switch case expressions list 2842 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_switch_case_expressions" 2843 * - possible values: { INSERT, DO_NOT_INSERT } 2844 * - default: INSERT 2845 * </pre> 2846 * @see JavaCore#INSERT 2847 * @see JavaCore#DO_NOT_INSERT 2848 * @since 3.18 2849 */ 2850 public static final String FORMATTER_INSERT_SPACE_AFTER_COMMA_IN_SWITCH_CASE_EXPRESSIONS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_comma_in_switch_case_expressions"; //$NON-NLS-1$ 2851 /** 2852 * <pre> 2853 * FORMATTER / Option to insert a space after the comma in explicit type arguments on method/constructor invocations 2854 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments" 2855 * - possible values: { INSERT, DO_NOT_INSERT } 2856 * - default: INSERT 2857 * </pre> 2858 * @see JavaCore#INSERT 2859 * @see JavaCore#DO_NOT_INSERT 2860 * @since 3.1 2861 */ 2862 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$ 2863 /** 2864 * <pre> 2865 * FORMATTER / Option to insert a space after the comma in type parameter declarations 2866 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters" 2867 * - possible values: { INSERT, DO_NOT_INSERT } 2868 * - default: INSERT 2869 * </pre> 2870 * @see JavaCore#INSERT 2871 * @see JavaCore#DO_NOT_INSERT 2872 * @since 3.1 2873 */ 2874 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$ 2875 /** 2876 * <pre> 2877 * FORMATTER / Option to insert a space after ellipsis 2878 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_ellipsis" 2879 * - possible values: { INSERT, DO_NOT_INSERT } 2880 * - default: INSERT 2881 * </pre> 2882 * @see JavaCore#INSERT 2883 * @see JavaCore#DO_NOT_INSERT 2884 * @since 3.1 2885 */ 2886 public static final String FORMATTER_INSERT_SPACE_AFTER_ELLIPSIS = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_ellipsis"; //$NON-NLS-1$ 2887 /** 2888 * <pre> 2889 * FORMATTER / Option to insert a space after the -> in lambda expressions 2890 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow" 2891 * - possible values: { INSERT, DO_NOT_INSERT } 2892 * - default: INSERT 2893 * </pre> 2894 * @see JavaCore#INSERT 2895 * @see JavaCore#DO_NOT_INSERT 2896 * @since 3.10 2897 */ 2898 public static final String FORMATTER_INSERT_SPACE_AFTER_LAMBDA_ARROW = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_lambda_arrow"; //$NON-NLS-1$ 2899 /** 2900 * <pre> 2901 * FORMATTER / Option to insert a space after the opening angle bracket in parameterized type reference 2902 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference" 2903 * - possible values: { INSERT, DO_NOT_INSERT } 2904 * - default: DO_NOT_INSERT 2905 * </pre> 2906 * @see JavaCore#INSERT 2907 * @see JavaCore#DO_NOT_INSERT 2908 * @since 3.1 2909 */ 2910 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$ 2911 /** 2912 * <pre> 2913 * FORMATTER / Option to insert a space after the opening angle bracket in explicit type arguments on method/constructor invocations 2914 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments" 2915 * - possible values: { INSERT, DO_NOT_INSERT } 2916 * - default: DO_NOT_INSERT 2917 * </pre> 2918 * @see JavaCore#INSERT 2919 * @see JavaCore#DO_NOT_INSERT 2920 * @since 3.1 2921 */ 2922 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$ 2923 /** 2924 * <pre> 2925 * FORMATTER / Option to insert a space after the opening angle bracket in type parameter declarations 2926 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters" 2927 * - possible values: { INSERT, DO_NOT_INSERT } 2928 * - default: DO_NOT_INSERT 2929 * </pre> 2930 * @see JavaCore#INSERT 2931 * @see JavaCore#DO_NOT_INSERT 2932 * @since 3.1 2933 */ 2934 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$ 2935 /** 2936 * <pre> 2937 * FORMATTER / Option to insert a space after the opening brace in an array initializer 2938 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" 2939 * - possible values: { INSERT, DO_NOT_INSERT } 2940 * - default: DO_NOT_INSERT 2941 * </pre> 2942 * @see JavaCore#INSERT 2943 * @see JavaCore#DO_NOT_INSERT 2944 * @since 3.0 2945 */ 2946 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$ 2947 /** 2948 * <pre> 2949 * FORMATTER / Option to insert a space after the opening bracket inside an array allocation expression 2950 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression" 2951 * - possible values: { INSERT, DO_NOT_INSERT } 2952 * - default: DO_NOT_INSERT 2953 * </pre> 2954 * @see JavaCore#INSERT 2955 * @see JavaCore#DO_NOT_INSERT 2956 * @since 3.0 2957 */ 2958 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$ 2959 /** 2960 * <pre> 2961 * FORMATTER / Option to insert a space after the opening bracket inside an array reference 2962 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference" 2963 * - possible values: { INSERT, DO_NOT_INSERT } 2964 * - default: DO_NOT_INSERT 2965 * </pre> 2966 * @see JavaCore#INSERT 2967 * @see JavaCore#DO_NOT_INSERT 2968 * @since 3.0 2969 */ 2970 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$ 2971 /** 2972 * <pre> 2973 * FORMATTER / Option to insert a space after the opening parenthesis in annotation 2974 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation" 2975 * - possible values: { INSERT, DO_NOT_INSERT } 2976 * - default: DO_NOT_INSERT 2977 * </pre> 2978 * @see JavaCore#INSERT 2979 * @see JavaCore#DO_NOT_INSERT 2980 * @since 3.1 2981 */ 2982 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$ 2983 /** 2984 * <pre> 2985 * FORMATTER / Option to insert a space after the opening parenthesis in a cast expression 2986 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast" 2987 * - possible values: { INSERT, DO_NOT_INSERT } 2988 * - default: DO_NOT_INSERT 2989 * </pre> 2990 * @see JavaCore#INSERT 2991 * @see JavaCore#DO_NOT_INSERT 2992 * @since 3.0 2993 */ 2994 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$ 2995 /** 2996 * <pre> 2997 * FORMATTER / Option to insert a space after the opening parenthesis in a catch 2998 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch" 2999 * - possible values: { INSERT, DO_NOT_INSERT } 3000 * - default: DO_NOT_INSERT 3001 * </pre> 3002 * @see JavaCore#INSERT 3003 * @see JavaCore#DO_NOT_INSERT 3004 * @since 3.0 3005 */ 3006 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$ 3007 /** 3008 * <pre> 3009 * FORMATTER / Option to insert a space after the opening parenthesis in a constructor declaration 3010 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration" 3011 * - possible values: { INSERT, DO_NOT_INSERT } 3012 * - default: DO_NOT_INSERT 3013 * </pre> 3014 * @see JavaCore#INSERT 3015 * @see JavaCore#DO_NOT_INSERT 3016 * @since 3.0 3017 */ 3018 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$ 3019 /** 3020 * <pre> 3021 * FORMATTER / Option to insert a space after the opening parenthesis in enum constant 3022 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant" 3023 * - possible values: { INSERT, DO_NOT_INSERT } 3024 * - default: DO_NOT_INSERT 3025 * </pre> 3026 * @see JavaCore#INSERT 3027 * @see JavaCore#DO_NOT_INSERT 3028 * @since 3.1 3029 */ 3030 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$ 3031 /** 3032 * <pre> 3033 * FORMATTER / Option to insert a space after the opening parenthesis in a for statement 3034 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for" 3035 * - possible values: { INSERT, DO_NOT_INSERT } 3036 * - default: DO_NOT_INSERT 3037 * </pre> 3038 * @see JavaCore#INSERT 3039 * @see JavaCore#DO_NOT_INSERT 3040 * @since 3.0 3041 */ 3042 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$ 3043 /** 3044 * <pre> 3045 * FORMATTER / Option to insert a space after the opening parenthesis in an if statement 3046 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if" 3047 * - possible values: { INSERT, DO_NOT_INSERT } 3048 * - default: DO_NOT_INSERT 3049 * </pre> 3050 * @see JavaCore#INSERT 3051 * @see JavaCore#DO_NOT_INSERT 3052 * @since 3.0 3053 */ 3054 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$ 3055 /** 3056 * <pre> 3057 * FORMATTER / Option to insert a space after the opening parenthesis in a method declaration 3058 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" 3059 * - possible values: { INSERT, DO_NOT_INSERT } 3060 * - default: DO_NOT_INSERT 3061 * </pre> 3062 * @see JavaCore#INSERT 3063 * @see JavaCore#DO_NOT_INSERT 3064 * @since 3.0 3065 */ 3066 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$ 3067 /** 3068 * <pre> 3069 * FORMATTER / Option to insert a space after the opening parenthesis in a method invocation 3070 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" 3071 * - possible values: { INSERT, DO_NOT_INSERT } 3072 * - default: DO_NOT_INSERT 3073 * </pre> 3074 * @see JavaCore#INSERT 3075 * @see JavaCore#DO_NOT_INSERT 3076 * @since 3.0 3077 */ 3078 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$ 3079 /** 3080 * <pre> 3081 * FORMATTER / Option to insert a space after the opening parenthesis in a parenthesized expression 3082 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression" 3083 * - possible values: { INSERT, DO_NOT_INSERT } 3084 * - default: DO_NOT_INSERT 3085 * </pre> 3086 * @see JavaCore#INSERT 3087 * @see JavaCore#DO_NOT_INSERT 3088 * @since 3.0 3089 */ 3090 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$ 3091 /** 3092 * <pre> 3093 * FORMATTER / Option to insert a space after the opening parenthesis in a record declaration 3094 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_record_declaration" 3095 * - possible values: { INSERT, DO_NOT_INSERT } 3096 * - default: DO_NOT_INSERT 3097 * </pre> 3098 * @see JavaCore#INSERT 3099 * @see JavaCore#DO_NOT_INSERT 3100 * @since 3.22 3101 */ 3102 public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_RECORD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_record_declaration"; //$NON-NLS-1$ 3103 /** 3104 * <pre> 3105 * FORMATTER / Option to insert a space after the opening parenthesis in a switch statement 3106 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch" 3107 * - possible values: { INSERT, DO_NOT_INSERT } 3108 * - default: DO_NOT_INSERT 3109 * </pre> 3110 * @see JavaCore#INSERT 3111 * @see JavaCore#DO_NOT_INSERT 3112 * @since 3.0 3113 */ 3114 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$ 3115 /** 3116 * <pre> 3117 * FORMATTER / Option to insert a space after the opening parenthesis in a synchronized statement 3118 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized" 3119 * - possible values: { INSERT, DO_NOT_INSERT } 3120 * - default: DO_NOT_INSERT 3121 * </pre> 3122 * @see JavaCore#INSERT 3123 * @see JavaCore#DO_NOT_INSERT 3124 * @since 3.0 3125 */ 3126 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$ 3127 /** 3128 * <pre> 3129 * FORMATTER / Option to insert a space after the opening parenthesis in a try with resources statement 3130 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try" 3131 * - possible values: { INSERT, DO_NOT_INSERT } 3132 * - default: DO_NOT_INSERT 3133 * </pre> 3134 * @see JavaCore#INSERT 3135 * @see JavaCore#DO_NOT_INSERT 3136 * @since 3.7.1 3137 */ 3138 public static final String FORMATTER_INSERT_SPACE_AFTER_OPENING_PAREN_IN_TRY = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_opening_paren_in_try"; //$NON-NLS-1$ 3139 /** 3140 * <pre> 3141 * FORMATTER / Option to insert a space after the opening parenthesis in a while statement 3142 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while" 3143 * - possible values: { INSERT, DO_NOT_INSERT } 3144 * - default: DO_NOT_INSERT 3145 * </pre> 3146 * @see JavaCore#INSERT 3147 * @see JavaCore#DO_NOT_INSERT 3148 * @since 3.0 3149 */ 3150 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$ 3151 /** 3152 * <pre> 3153 * FORMATTER / Option to insert a space after a postfix operator 3154 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator" 3155 * - possible values: { INSERT, DO_NOT_INSERT } 3156 * - default: DO_NOT_INSERT 3157 * </pre> 3158 * @see JavaCore#INSERT 3159 * @see JavaCore#DO_NOT_INSERT 3160 * @since 3.0 3161 */ 3162 public static final String FORMATTER_INSERT_SPACE_AFTER_POSTFIX_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_postfix_operator"; //$NON-NLS-1$ 3163 /** 3164 * <pre> 3165 * FORMATTER / Option to insert a space after a prefix operator 3166 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator" 3167 * - possible values: { INSERT, DO_NOT_INSERT } 3168 * - default: DO_NOT_INSERT 3169 * </pre> 3170 * @see JavaCore#INSERT 3171 * @see JavaCore#DO_NOT_INSERT 3172 * @since 3.0 3173 */ 3174 public static final String FORMATTER_INSERT_SPACE_AFTER_PREFIX_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_prefix_operator"; //$NON-NLS-1$ 3175 /** 3176 * <pre> 3177 * FORMATTER / Option to insert a space after question mark in a conditional expression 3178 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional" 3179 * - possible values: { INSERT, DO_NOT_INSERT } 3180 * - default: DO_NOT_INSERT 3181 * </pre> 3182 * @see JavaCore#INSERT 3183 * @see JavaCore#DO_NOT_INSERT 3184 * @since 3.0 3185 */ 3186 public static final String FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_CONDITIONAL = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_question_in_conditional"; //$NON-NLS-1$ 3187 /** 3188 * <pre> 3189 * FORMATTER / Option to insert a space after question mark in a wildcard 3190 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard" 3191 * - possible values: { INSERT, DO_NOT_INSERT } 3192 * - default: DO_NOT_INSERT 3193 * </pre> 3194 * @see JavaCore#INSERT 3195 * @see JavaCore#DO_NOT_INSERT 3196 * @since 3.1 3197 */ 3198 public static final String FORMATTER_INSERT_SPACE_AFTER_QUESTION_IN_WILDCARD = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_question_in_wildcard"; //$NON-NLS-1$ 3199 /** 3200 * <pre> 3201 * FORMATTER / Option to insert a space after semicolon in a for statement 3202 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for" 3203 * - possible values: { INSERT, DO_NOT_INSERT } 3204 * - default: INSERT 3205 * </pre> 3206 * @see JavaCore#INSERT 3207 * @see JavaCore#DO_NOT_INSERT 3208 * @since 3.0 3209 */ 3210 public static final String FORMATTER_INSERT_SPACE_AFTER_SEMICOLON_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_semicolon_in_for"; //$NON-NLS-1$ 3211 /** 3212 * <pre> 3213 * FORMATTER / Option to insert a space after semicolons following each resource declaration in a try with 3214 * resources statement 3215 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources" 3216 * - possible values: { INSERT, DO_NOT_INSERT } 3217 * - default: INSERT 3218 * </pre> 3219 * @see JavaCore#INSERT 3220 * @see JavaCore#DO_NOT_INSERT 3221 * @since 3.7.1 3222 */ 3223 public static final String FORMATTER_INSERT_SPACE_AFTER_SEMICOLON_IN_TRY_RESOURCES = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_semicolon_in_try_resources"; //$NON-NLS-1$ 3224 /** 3225 * <pre> 3226 * FORMATTER / Option to insert a space after an unary operator 3227 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_unary_operator" 3228 * - possible values: { INSERT, DO_NOT_INSERT } 3229 * - default: DO_NOT_INSERT 3230 * </pre> 3231 * @see JavaCore#INSERT 3232 * @see JavaCore#DO_NOT_INSERT 3233 * @since 3.0 3234 */ 3235 public static final String FORMATTER_INSERT_SPACE_AFTER_UNARY_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_unary_operator"; //$NON-NLS-1$ 3236 /** 3237 * <pre> 3238 * FORMATTER / Option to insert a space after 'not' operator 3239 * - option id: "org.eclipse.jdt.core.formatter.insert_space_after_not_operator" 3240 * - possible values: { INSERT, DO_NOT_INSERT } 3241 * - default: DO_NOT_INSERT 3242 * </pre> 3243 * @see JavaCore#INSERT 3244 * @see JavaCore#DO_NOT_INSERT 3245 * @since 3.20 3246 */ 3247 public static final String FORMATTER_INSERT_SPACE_AFTER_NOT_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_after_not_operator"; //$NON-NLS-1$ 3248 /** 3249 * <pre> 3250 * FORMATTER / Option to insert a space before and in wildcard 3251 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter" 3252 * - possible values: { INSERT, DO_NOT_INSERT } 3253 * - default: INSERT 3254 * </pre> 3255 * @see JavaCore#INSERT 3256 * @see JavaCore#DO_NOT_INSERT 3257 * @since 3.1 3258 */ 3259 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$ 3260 /** 3261 * <pre> 3262 * FORMATTER / Option to insert a space before arrow in switch case 3263 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case" 3264 * - possible values: { INSERT, DO_NOT_INSERT } 3265 * - default: INSERT 3266 * </pre> 3267 * @see JavaCore#INSERT 3268 * @see JavaCore#DO_NOT_INSERT 3269 * @since 3.18 3270 */ 3271 public static final String FORMATTER_INSERT_SPACE_BEFORE_ARROW_IN_SWITCH_CASE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_arrow_in_switch_case"; //$NON-NLS-1$ 3272 /** 3273 * <pre> 3274 * FORMATTER / Option to insert a space before arrow in switch default 3275 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_default" 3276 * - possible values: { INSERT, DO_NOT_INSERT } 3277 * - default: INSERT 3278 * </pre> 3279 * @see JavaCore#INSERT 3280 * @see JavaCore#DO_NOT_INSERT 3281 * @since 3.18 3282 */ 3283 public static final String FORMATTER_INSERT_SPACE_BEFORE_ARROW_IN_SWITCH_DEFAULT = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_arrow_in_switch_default"; //$NON-NLS-1$ 3284 /** 3285 * <pre> 3286 * FORMATTER / Option to insert a space before an assignment operator 3287 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator" 3288 * - possible values: { INSERT, DO_NOT_INSERT } 3289 * - default: INSERT 3290 * </pre> 3291 * @see JavaCore#INSERT 3292 * @see JavaCore#DO_NOT_INSERT 3293 * @since 3.0 3294 */ 3295 public static final String FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_assignment_operator"; //$NON-NLS-1$ 3296 /** 3297 * <pre> 3298 * FORMATTER / Option to insert a space before at in annotation type declaration 3299 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" 3300 * - possible values: { INSERT, DO_NOT_INSERT } 3301 * - default: INSERT 3302 * </pre> 3303 * @see JavaCore#INSERT 3304 * @see JavaCore#DO_NOT_INSERT 3305 * @since 3.1 3306 */ 3307 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$ 3308 /** 3309 * <pre> 3310 * FORMATTER / Option to insert a space before an binary operator 3311 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_binary_operator" 3312 * - possible values: { INSERT, DO_NOT_INSERT } 3313 * - default: DO_NOT_INSERT 3314 * </pre> 3315 * @see JavaCore#INSERT 3316 * @see JavaCore#DO_NOT_INSERT 3317 * @since 3.0 3318 * @deprecated Use the new settings instead: {@link #FORMATTER_INSERT_SPACE_BEFORE_MULTIPLICATIVE_OPERATOR}, 3319 * {@link #FORMATTER_INSERT_SPACE_BEFORE_ADDITIVE_OPERATOR}, {@link #FORMATTER_INSERT_SPACE_BEFORE_STRING_CONCATENATION}, 3320 * {@link #FORMATTER_INSERT_SPACE_BEFORE_SHIFT_OPERATOR}, {@link #FORMATTER_INSERT_SPACE_BEFORE_RELATIONAL_OPERATOR}, 3321 * {@link #FORMATTER_INSERT_SPACE_BEFORE_BITWISE_OPERATOR}, {@link #FORMATTER_INSERT_SPACE_BEFORE_LOGICAL_OPERATOR} 3322 */ 3323 public static final String FORMATTER_INSERT_SPACE_BEFORE_BINARY_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_binary_operator"; //$NON-NLS-1$ 3324 /** 3325 * <pre> 3326 * FORMATTER / Option to insert a space before a multiplicative operator (*, /, %) 3327 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator" 3328 * - possible values: { INSERT, DO_NOT_INSERT } 3329 * - default: INSERT 3330 * </pre> 3331 * @see JavaCore#INSERT 3332 * @see JavaCore#DO_NOT_INSERT 3333 * @since 3.17 3334 */ 3335 public static final String FORMATTER_INSERT_SPACE_BEFORE_MULTIPLICATIVE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_multiplicative_operator"; //$NON-NLS-1$ 3336 /** 3337 * <pre> 3338 * FORMATTER / Option to insert a space before an additive operator (+, -) 3339 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_additive_operator" 3340 * - possible values: { INSERT, DO_NOT_INSERT } 3341 * - default: INSERT 3342 * </pre> 3343 * @see JavaCore#INSERT 3344 * @see JavaCore#DO_NOT_INSERT 3345 * @since 3.17 3346 */ 3347 public static final String FORMATTER_INSERT_SPACE_BEFORE_ADDITIVE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_additive_operator"; //$NON-NLS-1$ 3348 /** 3349 * <pre> 3350 * FORMATTER / Option to insert a space before a string concatenation operator 3351 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation" 3352 * - possible values: { INSERT, DO_NOT_INSERT } 3353 * - default: INSERT 3354 * </pre> 3355 * @see JavaCore#INSERT 3356 * @see JavaCore#DO_NOT_INSERT 3357 * @since 3.17 3358 */ 3359 public static final String FORMATTER_INSERT_SPACE_BEFORE_STRING_CONCATENATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_string_concatenation"; //$NON-NLS-1$ 3360 /** 3361 * <pre> 3362 * FORMATTER / Option to insert a space before a shift operator (<<, >>, >>>) 3363 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_shift_operator" 3364 * - possible values: { INSERT, DO_NOT_INSERT } 3365 * - default: INSERT 3366 * </pre> 3367 * @see JavaCore#INSERT 3368 * @see JavaCore#DO_NOT_INSERT 3369 * @since 3.17 3370 */ 3371 public static final String FORMATTER_INSERT_SPACE_BEFORE_SHIFT_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_shift_operator"; //$NON-NLS-1$ 3372 /** 3373 * <pre> 3374 * FORMATTER / Option to insert a space before a relational operator (<, >, <=, >=, ==, !=) 3375 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_relational_operator" 3376 * - possible values: { INSERT, DO_NOT_INSERT } 3377 * - default: INSERT 3378 * </pre> 3379 * @see JavaCore#INSERT 3380 * @see JavaCore#DO_NOT_INSERT 3381 * @since 3.17 3382 */ 3383 public static final String FORMATTER_INSERT_SPACE_BEFORE_RELATIONAL_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_relational_operator"; //$NON-NLS-1$ 3384 /** 3385 * <pre> 3386 * FORMATTER / Option to insert a space before a bitwise operator (&, ^, |) 3387 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator" 3388 * - possible values: { INSERT, DO_NOT_INSERT } 3389 * - default: INSERT 3390 * </pre> 3391 * @see JavaCore#INSERT 3392 * @see JavaCore#DO_NOT_INSERT 3393 * @since 3.17 3394 */ 3395 public static final String FORMATTER_INSERT_SPACE_BEFORE_BITWISE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_bitwise_operator"; //$NON-NLS-1$ 3396 /** 3397 * <pre> 3398 * FORMATTER / Option to insert a space before a logical operator (&&, ||) 3399 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_logical_operator" 3400 * - possible values: { INSERT, DO_NOT_INSERT } 3401 * - default: INSERT 3402 * </pre> 3403 * @see JavaCore#INSERT 3404 * @see JavaCore#DO_NOT_INSERT 3405 * @since 3.17 3406 */ 3407 public static final String FORMATTER_INSERT_SPACE_BEFORE_LOGICAL_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_logical_operator"; //$NON-NLS-1$ 3408 /** 3409 * <pre> 3410 * FORMATTER / Option to insert a space before the closing angle bracket in parameterized type reference 3411 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference" 3412 * - possible values: { INSERT, DO_NOT_INSERT } 3413 * - default: DO_NOT_INSERT 3414 * </pre> 3415 * @see JavaCore#INSERT 3416 * @see JavaCore#DO_NOT_INSERT 3417 * @since 3.1 3418 */ 3419 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$ 3420 /** 3421 * <pre> 3422 * FORMATTER / Option to insert a space before the closing angle bracket in explicit type arguments on method/constructor invocations 3423 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments" 3424 * - possible values: { INSERT, DO_NOT_INSERT } 3425 * - default: DO_NOT_INSERT 3426 * </pre> 3427 * @see JavaCore#INSERT 3428 * @see JavaCore#DO_NOT_INSERT 3429 * @since 3.1 3430 */ 3431 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$ 3432 /** 3433 * <pre> 3434 * FORMATTER / Option to insert a space before the closing angle bracket in type parameter declarations 3435 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters" 3436 * - possible values: { INSERT, DO_NOT_INSERT } 3437 * - default: DO_NOT_INSERT 3438 * </pre> 3439 * @see JavaCore#INSERT 3440 * @see JavaCore#DO_NOT_INSERT 3441 * @since 3.1 3442 */ 3443 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$ 3444 /** 3445 * <pre> 3446 * FORMATTER / Option to insert a space before the closing brace in an array initializer 3447 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" 3448 * - possible values: { INSERT, DO_NOT_INSERT } 3449 * - default: DO_NOT_INSERT 3450 * </pre> 3451 * @see JavaCore#INSERT 3452 * @see JavaCore#DO_NOT_INSERT 3453 * @since 3.0 3454 */ 3455 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$ 3456 /** 3457 * <pre> 3458 * FORMATTER / Option to insert a space before the closing bracket in an array allocation expression 3459 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression" 3460 * - possible values: { INSERT, DO_NOT_INSERT } 3461 * - default: DO_NOT_INSERT 3462 * </pre> 3463 * @see JavaCore#INSERT 3464 * @see JavaCore#DO_NOT_INSERT 3465 * @since 3.0 3466 */ 3467 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$ 3468 /** 3469 * <pre> 3470 * FORMATTER / Option to insert a space before the closing bracket in an array reference 3471 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference" 3472 * - possible values: { INSERT, DO_NOT_INSERT } 3473 * - default: DO_NOT_INSERT 3474 * </pre> 3475 * @see JavaCore#INSERT 3476 * @see JavaCore#DO_NOT_INSERT 3477 * @since 3.0 3478 */ 3479 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$ 3480 /** 3481 * <pre> 3482 * FORMATTER / Option to insert a space before the closing parenthesis in annotation 3483 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation" 3484 * - possible values: { INSERT, DO_NOT_INSERT } 3485 * - default: DO_NOT_INSERT 3486 * </pre> 3487 * @see JavaCore#INSERT 3488 * @see JavaCore#DO_NOT_INSERT 3489 * @since 3.1 3490 */ 3491 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$ 3492 /** 3493 * <pre> 3494 * FORMATTER / Option to insert a space before the closing parenthesis in a cast expression 3495 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast" 3496 * - possible values: { INSERT, DO_NOT_INSERT } 3497 * - default: DO_NOT_INSERT 3498 * </pre> 3499 * @see JavaCore#INSERT 3500 * @see JavaCore#DO_NOT_INSERT 3501 * @since 3.0 3502 */ 3503 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$ 3504 /** 3505 * <pre> 3506 * FORMATTER / Option to insert a space before the closing parenthesis in a catch 3507 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch" 3508 * - possible values: { INSERT, DO_NOT_INSERT } 3509 * - default: DO_NOT_INSERT 3510 * </pre> 3511 * @see JavaCore#INSERT 3512 * @see JavaCore#DO_NOT_INSERT 3513 * @since 3.0 3514 */ 3515 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$ 3516 /** 3517 * <pre> 3518 * FORMATTER / Option to insert a space before the closing parenthesis in a constructor declaration 3519 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration" 3520 * - possible values: { INSERT, DO_NOT_INSERT } 3521 * - default: DO_NOT_INSERT 3522 * </pre> 3523 * @see JavaCore#INSERT 3524 * @see JavaCore#DO_NOT_INSERT 3525 * @since 3.0 3526 */ 3527 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$ 3528 /** 3529 * <pre> 3530 * FORMATTER / Option to insert a space before the closing parenthesis in enum constant 3531 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant" 3532 * - possible values: { INSERT, DO_NOT_INSERT } 3533 * - default: DO_NOT_INSERT 3534 * </pre> 3535 * @see JavaCore#INSERT 3536 * @see JavaCore#DO_NOT_INSERT 3537 * @since 3.1 3538 */ 3539 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$ 3540 /** 3541 * <pre> 3542 * FORMATTER / Option to insert a space before the closing parenthesis in a for statement 3543 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for" 3544 * - possible values: { INSERT, DO_NOT_INSERT } 3545 * - default: DO_NOT_INSERT 3546 * </pre> 3547 * @see JavaCore#INSERT 3548 * @see JavaCore#DO_NOT_INSERT 3549 * @since 3.0 3550 */ 3551 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$ 3552 /** 3553 * <pre> 3554 * FORMATTER / Option to insert a space before the closing parenthesis in an if statement 3555 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if" 3556 * - possible values: { INSERT, DO_NOT_INSERT } 3557 * - default: DO_NOT_INSERT 3558 * </pre> 3559 * @see JavaCore#INSERT 3560 * @see JavaCore#DO_NOT_INSERT 3561 * @since 3.0 3562 */ 3563 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$ 3564 /** 3565 * <pre> 3566 * FORMATTER / Option to insert a space before the closing parenthesis in a method declaration 3567 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" 3568 * - possible values: { INSERT, DO_NOT_INSERT } 3569 * - default: DO_NOT_INSERT 3570 * </pre> 3571 * @see JavaCore#INSERT 3572 * @see JavaCore#DO_NOT_INSERT 3573 * @since 3.0 3574 */ 3575 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$ 3576 /** 3577 * <pre> 3578 * FORMATTER / Option to insert a space before the closing parenthesis in a method invocation 3579 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" 3580 * - possible values: { INSERT, DO_NOT_INSERT } 3581 * - default: DO_NOT_INSERT 3582 * </pre> 3583 * @see JavaCore#INSERT 3584 * @see JavaCore#DO_NOT_INSERT 3585 * @since 3.0 3586 */ 3587 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$ 3588 /** 3589 * <pre> 3590 * FORMATTER / Option to insert a space before the closing parenthesis in a parenthesized expression 3591 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression" 3592 * - possible values: { INSERT, DO_NOT_INSERT } 3593 * - default: DO_NOT_INSERT 3594 * </pre> 3595 * @see JavaCore#INSERT 3596 * @see JavaCore#DO_NOT_INSERT 3597 * @since 3.0 3598 */ 3599 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$ 3600 /** 3601 * <pre> 3602 * FORMATTER / Option to insert a space before the closing parenthesis in a record declaration 3603 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_record_declaration" 3604 * - possible values: { INSERT, DO_NOT_INSERT } 3605 * - default: DO_NOT_INSERT 3606 * </pre> 3607 * @see JavaCore#INSERT 3608 * @see JavaCore#DO_NOT_INSERT 3609 * @since 3.22 3610 */ 3611 public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_RECORD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_record_declaration"; //$NON-NLS-1$ 3612 /** 3613 * <pre> 3614 * FORMATTER / Option to insert a space before the closing parenthesis in a switch statement 3615 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch" 3616 * - possible values: { INSERT, DO_NOT_INSERT } 3617 * - default: DO_NOT_INSERT 3618 * </pre> 3619 * @see JavaCore#INSERT 3620 * @see JavaCore#DO_NOT_INSERT 3621 * @since 3.0 3622 */ 3623 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$ 3624 /** 3625 * <pre> 3626 * FORMATTER / Option to insert a space before the closing parenthesis in a synchronized statement 3627 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized" 3628 * - possible values: { INSERT, DO_NOT_INSERT } 3629 * - default: DO_NOT_INSERT 3630 * </pre> 3631 * @see JavaCore#INSERT 3632 * @see JavaCore#DO_NOT_INSERT 3633 * @since 3.0 3634 */ 3635 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$ 3636 /** 3637 * <pre> 3638 * FORMATTER / Option to insert a space before the closing parenthesis in a try with resources statement 3639 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try" 3640 * - possible values: { INSERT, DO_NOT_INSERT } 3641 * - default: DO_NOT_INSERT 3642 * </pre> 3643 * @see JavaCore#INSERT 3644 * @see JavaCore#DO_NOT_INSERT 3645 * @since 3.7.1 3646 */ 3647 public static final String FORMATTER_INSERT_SPACE_BEFORE_CLOSING_PAREN_IN_TRY = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_closing_paren_in_try"; //$NON-NLS-1$ 3648 /** 3649 * <pre> 3650 * FORMATTER / Option to insert a space before the closing parenthesis in a while statement 3651 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while" 3652 * - possible values: { INSERT, DO_NOT_INSERT } 3653 * - default: DO_NOT_INSERT 3654 * </pre> 3655 * @see JavaCore#INSERT 3656 * @see JavaCore#DO_NOT_INSERT 3657 * @since 3.0 3658 */ 3659 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$ 3660 /** 3661 * <pre> 3662 * FORMATTER / Option to insert a space before colon in an assert statement 3663 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert" 3664 * - possible values: { INSERT, DO_NOT_INSERT } 3665 * - default: INSERT 3666 * </pre> 3667 * @see JavaCore#INSERT 3668 * @see JavaCore#DO_NOT_INSERT 3669 * @since 3.0 3670 */ 3671 public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_ASSERT = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_assert"; //$NON-NLS-1$ 3672 /** 3673 * <pre> 3674 * FORMATTER / Option to insert a space before colon in a case statement 3675 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" 3676 * - possible values: { INSERT, DO_NOT_INSERT } 3677 * - default: INSERT 3678 * </pre> 3679 * @see JavaCore#INSERT 3680 * @see JavaCore#DO_NOT_INSERT 3681 * @since 3.0 3682 */ 3683 public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CASE = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_case"; //$NON-NLS-1$ 3684 /** 3685 * <pre> 3686 * FORMATTER / Option to insert a space before colon in a conditional expression 3687 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" 3688 * - possible values: { INSERT, DO_NOT_INSERT } 3689 * - default: INSERT 3690 * </pre> 3691 * @see JavaCore#INSERT 3692 * @see JavaCore#DO_NOT_INSERT 3693 * @since 3.0 3694 */ 3695 public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_CONDITIONAL = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_conditional"; //$NON-NLS-1$ 3696 /** 3697 * <pre> 3698 * FORMATTER / Option to insert a space before colon in a default statement 3699 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" 3700 * - possible values: { INSERT, DO_NOT_INSERT } 3701 * - default: INSERT 3702 * </pre> 3703 * @see JavaCore#INSERT 3704 * @see JavaCore#DO_NOT_INSERT 3705 * @since 3.0 3706 */ 3707 public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_DEFAULT = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_default"; //$NON-NLS-1$ 3708 /** 3709 * <pre> 3710 * FORMATTER / Option to insert a space before colon in a for statement 3711 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for" 3712 * - possible values: { INSERT, DO_NOT_INSERT } 3713 * - default: INSERT 3714 * </pre> 3715 * @see JavaCore#INSERT 3716 * @see JavaCore#DO_NOT_INSERT 3717 * @since 3.1 3718 */ 3719 public static final String FORMATTER_INSERT_SPACE_BEFORE_COLON_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_colon_in_for"; //$NON-NLS-1$ 3720 /** 3721 * <pre> 3722 * FORMATTER / Option to insert a space before colon in a labeled statement 3723 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" 3724 * - possible values: { INSERT, DO_NOT_INSERT } 3725 * - default: INSERT 3726 * </pre> 3727 * @see JavaCore#INSERT 3728 * @see JavaCore#DO_NOT_INSERT 3729 * @since 3.0 3730 */ 3731 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$ 3732 /** 3733 * <pre> 3734 * FORMATTER / Option to insert a space before comma in an allocation expression 3735 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression" 3736 * - possible values: { INSERT, DO_NOT_INSERT } 3737 * - default: DO_NOT_INSERT 3738 * </pre> 3739 * @see JavaCore#INSERT 3740 * @see JavaCore#DO_NOT_INSERT 3741 * @since 3.0 3742 */ 3743 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$ 3744 /** 3745 * <pre> 3746 * FORMATTER / Option to insert a space before comma in annotation 3747 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation" 3748 * - possible values: { INSERT, DO_NOT_INSERT } 3749 * - default: DO_NOT_INSERT 3750 * </pre> 3751 * @see JavaCore#INSERT 3752 * @see JavaCore#DO_NOT_INSERT 3753 * @since 3.1 3754 */ 3755 public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_ANNOTATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_annotation"; //$NON-NLS-1$ 3756 /** 3757 * <pre> 3758 * FORMATTER / Option to insert a space before comma in an array initializer 3759 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer" 3760 * - possible values: { INSERT, DO_NOT_INSERT } 3761 * - default: DO_NOT_INSERT 3762 * </pre> 3763 * @see JavaCore#INSERT 3764 * @see JavaCore#DO_NOT_INSERT 3765 * @since 3.0 3766 */ 3767 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$ 3768 /** 3769 * <pre> 3770 * FORMATTER / Option to insert a space before comma in the parameters of a constructor declaration 3771 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters" 3772 * - possible values: { INSERT, DO_NOT_INSERT } 3773 * - default: DO_NOT_INSERT 3774 * </pre> 3775 * @see JavaCore#INSERT 3776 * @see JavaCore#DO_NOT_INSERT 3777 * @since 3.0 3778 */ 3779 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$ 3780 /** 3781 * <pre> 3782 * FORMATTER / Option to insert a space before comma in the exception names of the throws clause of a constructor declaration 3783 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws" 3784 * - possible values: { INSERT, DO_NOT_INSERT } 3785 * - default: DO_NOT_INSERT 3786 * </pre> 3787 * @see JavaCore#INSERT 3788 * @see JavaCore#DO_NOT_INSERT 3789 * @since 3.0 3790 */ 3791 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$ 3792 /** 3793 * <pre> 3794 * FORMATTER / Option to insert a space before comma in the arguments of enum constant 3795 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments" 3796 * - possible values: { INSERT, DO_NOT_INSERT } 3797 * - default: DO_NOT_INSERT 3798 * </pre> 3799 * @see JavaCore#INSERT 3800 * @see JavaCore#DO_NOT_INSERT 3801 * @since 3.1 3802 */ 3803 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$ 3804 /** 3805 * <pre> 3806 * FORMATTER / Option to insert a space before comma in enum declarations 3807 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations" 3808 * - possible values: { INSERT, DO_NOT_INSERT } 3809 * - default: DO_NOT_INSERT 3810 * </pre> 3811 * @see JavaCore#INSERT 3812 * @see JavaCore#DO_NOT_INSERT 3813 * @since 3.1 3814 */ 3815 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$ 3816 /** 3817 * <pre> 3818 * FORMATTER / Option to insert a space before comma in the arguments of an explicit constructor call 3819 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments" 3820 * - possible values: { INSERT, DO_NOT_INSERT } 3821 * - default: DO_NOT_INSERT 3822 * </pre> 3823 * @see JavaCore#INSERT 3824 * @see JavaCore#DO_NOT_INSERT 3825 * @since 3.0 3826 */ 3827 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$ 3828 /** 3829 * <pre> 3830 * FORMATTER / Option to insert a space before comma in the increments of a for statement 3831 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments" 3832 * - possible values: { INSERT, DO_NOT_INSERT } 3833 * - default: DO_NOT_INSERT 3834 * </pre> 3835 * @see JavaCore#INSERT 3836 * @see JavaCore#DO_NOT_INSERT 3837 * @since 3.0 3838 */ 3839 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$ 3840 /** 3841 * <pre> 3842 * FORMATTER / Option to insert a space before comma in the initializations of a for statement 3843 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits" 3844 * - possible values: { INSERT, DO_NOT_INSERT } 3845 * - default: DO_NOT_INSERT 3846 * </pre> 3847 * @see JavaCore#INSERT 3848 * @see JavaCore#DO_NOT_INSERT 3849 * @since 3.0 3850 */ 3851 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$ 3852 /** 3853 * <pre> 3854 * FORMATTER / Option to insert a space before comma in the parameters of a method declaration 3855 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" 3856 * - possible values: { INSERT, DO_NOT_INSERT } 3857 * - default: DO_NOT_INSERT 3858 * </pre> 3859 * @see JavaCore#INSERT 3860 * @see JavaCore#DO_NOT_INSERT 3861 * @since 3.0 3862 */ 3863 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$ 3864 /** 3865 * <pre> 3866 * FORMATTER / Option to insert a space before comma in the exception names of the throws clause of a method declaration 3867 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws" 3868 * - possible values: { INSERT, DO_NOT_INSERT } 3869 * - default: DO_NOT_INSERT 3870 * </pre> 3871 * @see JavaCore#INSERT 3872 * @see JavaCore#DO_NOT_INSERT 3873 * @since 3.0 3874 */ 3875 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$ 3876 /** 3877 * <pre> 3878 * FORMATTER / Option to insert a space before comma in the arguments of a method invocation 3879 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" 3880 * - possible values: { INSERT, DO_NOT_INSERT } 3881 * - default: DO_NOT_INSERT 3882 * </pre> 3883 * @see JavaCore#INSERT 3884 * @see JavaCore#DO_NOT_INSERT 3885 * @since 3.0 3886 */ 3887 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$ 3888 /** 3889 * <pre> 3890 * FORMATTER / Option to insert a space before comma in a multiple field declaration 3891 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations" 3892 * - possible values: { INSERT, DO_NOT_INSERT } 3893 * - default: DO_NOT_INSERT 3894 * </pre> 3895 * @see JavaCore#INSERT 3896 * @see JavaCore#DO_NOT_INSERT 3897 * @since 3.0 3898 */ 3899 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$ 3900 /** 3901 * <pre> 3902 * FORMATTER / Option to insert a space before comma in a multiple local declaration 3903 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations" 3904 * - possible values: { INSERT, DO_NOT_INSERT } 3905 * - default: DO_NOT_INSERT 3906 * </pre> 3907 * @see JavaCore#INSERT 3908 * @see JavaCore#DO_NOT_INSERT 3909 * @since 3.0 3910 */ 3911 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$ 3912 /** 3913 * <pre> 3914 * FORMATTER / Option to insert a space before comma in parameterized type reference 3915 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference" 3916 * - possible values: { INSERT, DO_NOT_INSERT } 3917 * - default: DO_NOT_INSERT 3918 * </pre> 3919 * @see JavaCore#INSERT 3920 * @see JavaCore#DO_NOT_INSERT 3921 * @since 3.1 3922 */ 3923 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$ 3924 /** 3925 * <pre> 3926 * FORMATTER / Option to insert a space before comma in record components list 3927 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_record_components" 3928 * - possible values: { INSERT, DO_NOT_INSERT } 3929 * - default: DO_NOT_INSERT 3930 * </pre> 3931 * @see JavaCore#INSERT 3932 * @see JavaCore#DO_NOT_INSERT 3933 * @since 3.22 3934 */ 3935 public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_RECORD_COMPONENTS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_record_components"; //$NON-NLS-1$ 3936 /** 3937 * <pre> 3938 * FORMATTER / Option to insert a space before comma in the superinterfaces names in a type header 3939 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces" 3940 * - possible values: { INSERT, DO_NOT_INSERT } 3941 * - default: DO_NOT_INSERT 3942 * </pre> 3943 * @see JavaCore#INSERT 3944 * @see JavaCore#DO_NOT_INSERT 3945 * @since 3.0 3946 */ 3947 public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_SUPERINTERFACES = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_superinterfaces"; //$NON-NLS-1$ 3948 /** 3949 * <pre> 3950 * FORMATTER / Option to insert a space before the comma in switch case expressions list 3951 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_switch_case_expressions" 3952 * - possible values: { INSERT, DO_NOT_INSERT } 3953 * - default: DO_NOT_INSERT 3954 * </pre> 3955 * @see JavaCore#INSERT 3956 * @see JavaCore#DO_NOT_INSERT 3957 * @since 3.18 3958 */ 3959 public static final String FORMATTER_INSERT_SPACE_BEFORE_COMMA_IN_SWITCH_CASE_EXPRESSIONS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_comma_in_switch_case_expressions"; //$NON-NLS-1$ 3960 /** 3961 * <pre> 3962 * FORMATTER / Option to insert a space before comma in explicit type arguments on method/constructor invocations 3963 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments" 3964 * - possible values: { INSERT, DO_NOT_INSERT } 3965 * - default: DO_NOT_INSERT 3966 * </pre> 3967 * @see JavaCore#INSERT 3968 * @see JavaCore#DO_NOT_INSERT 3969 * @since 3.1 3970 */ 3971 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$ 3972 /** 3973 * <pre> 3974 * FORMATTER / Option to insert a space before comma in type parameter declarations 3975 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters" 3976 * - possible values: { INSERT, DO_NOT_INSERT } 3977 * - default: DO_NOT_INSERT 3978 * </pre> 3979 * @see JavaCore#INSERT 3980 * @see JavaCore#DO_NOT_INSERT 3981 * @since 3.1 3982 */ 3983 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$ 3984 /** 3985 * <pre> 3986 * FORMATTER / Option to insert a space before ellipsis 3987 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_ellipsis" 3988 * - possible values: { INSERT, DO_NOT_INSERT } 3989 * - default: DO_NOT_INSERT 3990 * </pre> 3991 * @see JavaCore#INSERT 3992 * @see JavaCore#DO_NOT_INSERT 3993 * @since 3.1 3994 */ 3995 public static final String FORMATTER_INSERT_SPACE_BEFORE_ELLIPSIS = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_ellipsis"; //$NON-NLS-1$ 3996 /** 3997 * <pre> 3998 * FORMATTER / Option to insert a space before lambda -> 3999 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow" 4000 * - possible values: { INSERT, DO_NOT_INSERT } 4001 * - default: INSERT 4002 * </pre> 4003 * @see JavaCore#INSERT 4004 * @see JavaCore#DO_NOT_INSERT 4005 * @since 3.10 4006 */ 4007 public static final String FORMATTER_INSERT_SPACE_BEFORE_LAMBDA_ARROW = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_lambda_arrow"; //$NON-NLS-1$ 4008 /** 4009 * <pre> 4010 * FORMATTER / Option to insert a space before the opening angle bracket in parameterized type reference 4011 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference" 4012 * - possible values: { INSERT, DO_NOT_INSERT } 4013 * - default: DO_NOT_INSERT 4014 * </pre> 4015 * @see JavaCore#INSERT 4016 * @see JavaCore#DO_NOT_INSERT 4017 * @since 3.1 4018 */ 4019 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$ 4020 /** 4021 * <pre> 4022 * FORMATTER / Option to insert a space before the opening angle bracket in explicit type arguments on method/constructor invocations 4023 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments" 4024 * - possible values: { INSERT, DO_NOT_INSERT } 4025 * - default: DO_NOT_INSERT 4026 * </pre> 4027 * @see JavaCore#INSERT 4028 * @see JavaCore#DO_NOT_INSERT 4029 * @since 3.1 4030 */ 4031 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$ 4032 /** 4033 * <pre> 4034 * FORMATTER / Option to insert a space before the opening angle bracket in type parameter declarations 4035 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters" 4036 * - possible values: { INSERT, DO_NOT_INSERT } 4037 * - default: DO_NOT_INSERT 4038 * </pre> 4039 * @see JavaCore#INSERT 4040 * @see JavaCore#DO_NOT_INSERT 4041 * @since 3.1 4042 */ 4043 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$ 4044 /** 4045 * <pre> 4046 * FORMATTER / Option to insert a space before the opening brace in an annotation type declaration 4047 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration" 4048 * - possible values: { INSERT, DO_NOT_INSERT } 4049 * - default: INSERT 4050 * </pre> 4051 * @see JavaCore#INSERT 4052 * @see JavaCore#DO_NOT_INSERT 4053 * @since 3.1 4054 */ 4055 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$ 4056 /** 4057 * <pre> 4058 * FORMATTER / Option to insert a space before the opening brace in an anonymous type declaration 4059 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration" 4060 * - possible values: { INSERT, DO_NOT_INSERT } 4061 * - default: INSERT 4062 * </pre> 4063 * @see JavaCore#INSERT 4064 * @see JavaCore#DO_NOT_INSERT 4065 * @since 3.0 4066 */ 4067 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$ 4068 /** 4069 * <pre> 4070 * FORMATTER / Option to insert a space before the opening brace in an array initializer 4071 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" 4072 * - possible values: { INSERT, DO_NOT_INSERT } 4073 * - default: DO_NOT_INSERT 4074 * </pre> 4075 * @see JavaCore#INSERT 4076 * @see JavaCore#DO_NOT_INSERT 4077 * @since 3.0 4078 */ 4079 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$ 4080 /** 4081 * <pre> 4082 * FORMATTER / Option to insert a space before the opening brace in a block 4083 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" 4084 * - possible values: { INSERT, DO_NOT_INSERT } 4085 * - default: INSERT 4086 * </pre> 4087 * @see JavaCore#INSERT 4088 * @see JavaCore#DO_NOT_INSERT 4089 * @since 3.0 4090 */ 4091 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$ 4092 /** 4093 * <pre> 4094 * FORMATTER / Option to insert a space before the opening brace in a constructor declaration 4095 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration" 4096 * - possible values: { INSERT, DO_NOT_INSERT } 4097 * - default: INSERT 4098 * </pre> 4099 * @see JavaCore#INSERT 4100 * @see JavaCore#DO_NOT_INSERT 4101 * @since 3.0 4102 */ 4103 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$ 4104 /** 4105 * <pre> 4106 * FORMATTER / Option to insert a space before the opening brace in an enum constant 4107 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant" 4108 * - possible values: { INSERT, DO_NOT_INSERT } 4109 * - default: INSERT 4110 * </pre> 4111 * @see JavaCore#INSERT 4112 * @see JavaCore#DO_NOT_INSERT 4113 * @since 3.1 4114 */ 4115 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$ 4116 /** 4117 * <pre> 4118 * FORMATTER / Option to insert a space before the opening brace in an enum declaration 4119 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" 4120 * - possible values: { INSERT, DO_NOT_INSERT } 4121 * - default: INSERT 4122 * </pre> 4123 * @see JavaCore#INSERT 4124 * @see JavaCore#DO_NOT_INSERT 4125 * @since 3.1 4126 */ 4127 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$ 4128 /** 4129 * <pre> 4130 * FORMATTER / Option to insert a space before the opening brace in a method declaration 4131 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" 4132 * - possible values: { INSERT, DO_NOT_INSERT } 4133 * - default: INSERT 4134 * </pre> 4135 * @see JavaCore#INSERT 4136 * @see JavaCore#DO_NOT_INSERT 4137 * @since 3.0 4138 */ 4139 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$ 4140 /** 4141 * <pre> 4142 * FORMATTER / Option to insert a space before the opening brace in a record constructor 4143 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_constructor" 4144 * - possible values: { INSERT, DO_NOT_INSERT } 4145 * - default: INSERT 4146 * </pre> 4147 * @see JavaCore#INSERT 4148 * @see JavaCore#DO_NOT_INSERT 4149 * @since 3.22 4150 */ 4151 public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_RECORD_CONSTRUCTOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_record_constructor"; //$NON-NLS-1$ 4152 /** 4153 * <pre> 4154 * FORMATTER / Option to insert a space before the opening brace in a record declaration 4155 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_declaration" 4156 * - possible values: { INSERT, DO_NOT_INSERT } 4157 * - default: INSERT 4158 * </pre> 4159 * @see JavaCore#INSERT 4160 * @see JavaCore#DO_NOT_INSERT 4161 * @since 3.22 4162 */ 4163 public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_BRACE_IN_RECORD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_brace_in_record_declaration"; //$NON-NLS-1$ 4164 /** 4165 * <pre> 4166 * FORMATTER / Option to insert a space before the opening brace in a switch statement 4167 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch" 4168 * - possible values: { INSERT, DO_NOT_INSERT } 4169 * - default: INSERT 4170 * </pre> 4171 * @see JavaCore#INSERT 4172 * @see JavaCore#DO_NOT_INSERT 4173 * @since 3.0 4174 */ 4175 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$ 4176 /** 4177 * <pre> 4178 * FORMATTER / Option to insert a space before the opening brace in a type declaration 4179 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" 4180 * - possible values: { INSERT, DO_NOT_INSERT } 4181 * - default: INSERT 4182 * </pre> 4183 * @see JavaCore#INSERT 4184 * @see JavaCore#DO_NOT_INSERT 4185 * @since 3.0 4186 */ 4187 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$ 4188 /** 4189 * <pre> 4190 * FORMATTER / Option to insert a space before the opening bracket in an array allocation expression 4191 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression" 4192 * - possible values: { INSERT, DO_NOT_INSERT } 4193 * - default: DO_NOT_INSERT 4194 * </pre> 4195 * @see JavaCore#INSERT 4196 * @see JavaCore#DO_NOT_INSERT 4197 * @since 3.0 4198 */ 4199 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$ 4200 /** 4201 * <pre> 4202 * FORMATTER / Option to insert a space before the opening bracket in an array reference 4203 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference" 4204 * - possible values: { INSERT, DO_NOT_INSERT } 4205 * - default: DO_NOT_INSERT 4206 * </pre> 4207 * @see JavaCore#INSERT 4208 * @see JavaCore#DO_NOT_INSERT 4209 * @since 3.0 4210 */ 4211 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$ 4212 /** 4213 * <pre> 4214 * FORMATTER / Option to insert a space before the opening bracket in an array type reference 4215 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference" 4216 * - possible values: { INSERT, DO_NOT_INSERT } 4217 * - default: DO_NOT_INSERT 4218 * </pre> 4219 * @see JavaCore#INSERT 4220 * @see JavaCore#DO_NOT_INSERT 4221 * @since 3.0 4222 */ 4223 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$ 4224 /** 4225 * <pre> 4226 * FORMATTER / Option to insert a space before the opening parenthesis in annotation 4227 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation" 4228 * - possible values: { INSERT, DO_NOT_INSERT } 4229 * - default: DO_NOT_INSERT 4230 * </pre> 4231 * @see JavaCore#INSERT 4232 * @see JavaCore#DO_NOT_INSERT 4233 * @since 3.1 4234 */ 4235 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$ 4236 /** 4237 * <pre> 4238 * FORMATTER / Option to insert a space before the opening parenthesis in annotation type member declaration 4239 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration" 4240 * - possible values: { INSERT, DO_NOT_INSERT } 4241 * - default: DO_NOT_INSERT 4242 * </pre> 4243 * @see JavaCore#INSERT 4244 * @see JavaCore#DO_NOT_INSERT 4245 * @since 3.1 4246 */ 4247 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$ 4248 /** 4249 * <pre> 4250 * FORMATTER / Option to insert a space before the opening parenthesis in a catch 4251 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch" 4252 * - possible values: { INSERT, DO_NOT_INSERT } 4253 * - default: INSERT 4254 * </pre> 4255 * @see JavaCore#INSERT 4256 * @see JavaCore#DO_NOT_INSERT 4257 * @since 3.0 4258 */ 4259 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$ 4260 /** 4261 * <pre> 4262 * FORMATTER / Option to insert a space before the opening parenthesis in a constructor declaration 4263 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration" 4264 * - possible values: { INSERT, DO_NOT_INSERT } 4265 * - default: DO_NOT_INSERT 4266 * </pre> 4267 * @see JavaCore#INSERT 4268 * @see JavaCore#DO_NOT_INSERT 4269 * @since 3.0 4270 */ 4271 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$ 4272 /** 4273 * <pre> 4274 * FORMATTER / Option to insert a space before the opening parenthesis in enum constant 4275 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant" 4276 * - possible values: { INSERT, DO_NOT_INSERT } 4277 * - default: DO_NOT_INSERT 4278 * </pre> 4279 * @see JavaCore#INSERT 4280 * @see JavaCore#DO_NOT_INSERT 4281 * @since 3.1 4282 */ 4283 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$ 4284 /** 4285 * <pre> 4286 * FORMATTER / Option to insert a space before the opening parenthesis in a for statement 4287 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for" 4288 * - possible values: { INSERT, DO_NOT_INSERT } 4289 * - default: INSERT 4290 * </pre> 4291 * @see JavaCore#INSERT 4292 * @see JavaCore#DO_NOT_INSERT 4293 * @since 3.0 4294 */ 4295 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$ 4296 /** 4297 * <pre> 4298 * FORMATTER / Option to insert a space before the opening parenthesis in an if statement 4299 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if" 4300 * - possible values: { INSERT, DO_NOT_INSERT } 4301 * - default: INSERT 4302 * </pre> 4303 * @see JavaCore#INSERT 4304 * @see JavaCore#DO_NOT_INSERT 4305 * @since 3.0 4306 */ 4307 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$ 4308 /** 4309 * <pre> 4310 * FORMATTER / Option to insert a space before the opening parenthesis in a method declaration 4311 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" 4312 * - possible values: { INSERT, DO_NOT_INSERT } 4313 * - default: DO_NOT_INSERT 4314 * </pre> 4315 * @see JavaCore#INSERT 4316 * @see JavaCore#DO_NOT_INSERT 4317 * @since 3.0 4318 */ 4319 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$ 4320 /** 4321 * <pre> 4322 * FORMATTER / Option to insert a space before the opening parenthesis in a method invocation 4323 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" 4324 * - possible values: { INSERT, DO_NOT_INSERT } 4325 * - default: DO_NOT_INSERT 4326 * </pre> 4327 * @see JavaCore#INSERT 4328 * @see JavaCore#DO_NOT_INSERT 4329 * @since 3.0 4330 */ 4331 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$ 4332 /** 4333 * <pre> 4334 * FORMATTER / Option to insert a space before the opening parenthesis in a parenthesized expression 4335 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression" 4336 * - possible values: { INSERT, DO_NOT_INSERT } 4337 * - default: DO_NOT_INSERT 4338 * </pre> 4339 * @see JavaCore#INSERT 4340 * @see JavaCore#DO_NOT_INSERT 4341 * @since 3.0 4342 */ 4343 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$ 4344 /** 4345 * <pre> 4346 * FORMATTER / Option to insert a space before the opening parenthesis in a record declaration 4347 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_record_declaration" 4348 * - possible values: { INSERT, DO_NOT_INSERT } 4349 * - default: DO_NOT_INSERT 4350 * </pre> 4351 * @see JavaCore#INSERT 4352 * @see JavaCore#DO_NOT_INSERT 4353 * @since 3.22 4354 */ 4355 public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_RECORD_DECLARATION = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_record_declaration"; //$NON-NLS-1$ 4356 /** 4357 * <pre> 4358 * FORMATTER / Option to insert a space before the opening parenthesis in a switch statement 4359 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch" 4360 * - possible values: { INSERT, DO_NOT_INSERT } 4361 * - default: INSERT 4362 * </pre> 4363 * @see JavaCore#INSERT 4364 * @see JavaCore#DO_NOT_INSERT 4365 * @since 3.0 4366 */ 4367 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$ 4368 /** 4369 * <pre> 4370 * FORMATTER / Option to insert a space before the opening parenthesis in a synchronized statement 4371 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized" 4372 * - possible values: { INSERT, DO_NOT_INSERT } 4373 * - default: INSERT 4374 * </pre> 4375 * @see JavaCore#INSERT 4376 * @see JavaCore#DO_NOT_INSERT 4377 * @since 3.0 4378 */ 4379 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$ 4380 /** 4381 * <pre> 4382 * FORMATTER / Option to insert a space before the opening parenthesis in a try with resources statement 4383 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try" 4384 * - possible values: { INSERT, DO_NOT_INSERT } 4385 * - default: INSERT 4386 * </pre> 4387 * @see JavaCore#INSERT 4388 * @see JavaCore#DO_NOT_INSERT 4389 * @since 3.7.1 4390 */ 4391 public static final String FORMATTER_INSERT_SPACE_BEFORE_OPENING_PAREN_IN_TRY = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_opening_paren_in_try"; //$NON-NLS-1$ 4392 /** 4393 * <pre> 4394 * FORMATTER / Option to insert a space before the opening parenthesis in a while statement 4395 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while" 4396 * - possible values: { INSERT, DO_NOT_INSERT } 4397 * - default: INSERT 4398 * </pre> 4399 * @see JavaCore#INSERT 4400 * @see JavaCore#DO_NOT_INSERT 4401 * @since 3.0 4402 */ 4403 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$ 4404 /** 4405 * <pre> 4406 * FORMATTER / Option to insert a space before parenthesized expression in return statement 4407 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" 4408 * - possible values: { INSERT, DO_NOT_INSERT } 4409 * - default: INSERT 4410 * </pre> 4411 * 4412 * @see JavaCore#INSERT 4413 * @see JavaCore#DO_NOT_INSERT 4414 * @since 3.2 4415 */ 4416 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$ 4417 /** 4418 * <pre> 4419 * FORMATTER / Option to insert a space before parenthesized expression in throw statement 4420 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw" 4421 * - possible values: { INSERT, DO_NOT_INSERT } 4422 * - default: INSERT 4423 * </pre> 4424 * 4425 * @see JavaCore#INSERT 4426 * @see JavaCore#DO_NOT_INSERT 4427 * @since 3.3 4428 */ 4429 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$ 4430 /** 4431 * <pre> 4432 * FORMATTER / Option to insert a space before a postfix operator 4433 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator" 4434 * - possible values: { INSERT, DO_NOT_INSERT } 4435 * - default: DO_NOT_INSERT 4436 * </pre> 4437 * @see JavaCore#INSERT 4438 * @see JavaCore#DO_NOT_INSERT 4439 * @since 3.0 4440 */ 4441 public static final String FORMATTER_INSERT_SPACE_BEFORE_POSTFIX_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_postfix_operator"; //$NON-NLS-1$ 4442 /** 4443 * <pre> 4444 * FORMATTER / Option to insert a space before a prefix operator 4445 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator" 4446 * - possible values: { INSERT, DO_NOT_INSERT } 4447 * - default: DO_NOT_INSERT 4448 * </pre> 4449 * @see JavaCore#INSERT 4450 * @see JavaCore#DO_NOT_INSERT 4451 * @since 3.0 4452 */ 4453 public static final String FORMATTER_INSERT_SPACE_BEFORE_PREFIX_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_prefix_operator"; //$NON-NLS-1$ 4454 /** 4455 * <pre> 4456 * FORMATTER / Option to insert a space before question mark in a conditional expression 4457 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional" 4458 * - possible values: { INSERT, DO_NOT_INSERT } 4459 * - default: INSERT 4460 * </pre> 4461 * @see JavaCore#INSERT 4462 * @see JavaCore#DO_NOT_INSERT 4463 * @since 3.0 4464 */ 4465 public static final String FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_CONDITIONAL = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_question_in_conditional"; //$NON-NLS-1$ 4466 /** 4467 * <pre> 4468 * FORMATTER / Option to insert a space before question mark in a wildcard 4469 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard" 4470 * - possible values: { INSERT, DO_NOT_INSERT } 4471 * - default: DO_NOT_INSERT 4472 * </pre> 4473 * @see JavaCore#INSERT 4474 * @see JavaCore#DO_NOT_INSERT 4475 * @since 3.1 4476 */ 4477 public static final String FORMATTER_INSERT_SPACE_BEFORE_QUESTION_IN_WILDCARD = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_question_in_wildcard"; //$NON-NLS-1$ 4478 /** 4479 * <pre> 4480 * FORMATTER / Option to insert a space before semicolon 4481 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_semicolon" 4482 * - possible values: { INSERT, DO_NOT_INSERT } 4483 * - default: DO_NOT_INSERT 4484 * </pre> 4485 * @see JavaCore#INSERT 4486 * @see JavaCore#DO_NOT_INSERT 4487 * @since 3.0 4488 */ 4489 public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_semicolon"; //$NON-NLS-1$ 4490 /** 4491 * <pre> 4492 * FORMATTER / Option to insert a space before semicolon in for statement 4493 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for" 4494 * - possible values: { INSERT, DO_NOT_INSERT } 4495 * - default: DO_NOT_INSERT 4496 * </pre> 4497 * @see JavaCore#INSERT 4498 * @see JavaCore#DO_NOT_INSERT 4499 * @since 3.0 4500 */ 4501 public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON_IN_FOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_semicolon_in_for"; //$NON-NLS-1$ 4502 /** 4503 * <pre> 4504 * FORMATTER / Option to insert a space before semicolons following each resource declaration in a try with 4505 * resources statement 4506 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources" 4507 * - possible values: { INSERT, DO_NOT_INSERT } 4508 * - default: DO_NOT_INSERT 4509 * </pre> 4510 * @see JavaCore#INSERT 4511 * @see JavaCore#DO_NOT_INSERT 4512 * @since 3.7.1 4513 */ 4514 public static final String FORMATTER_INSERT_SPACE_BEFORE_SEMICOLON_IN_TRY_RESOURCES = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_semicolon_in_try_resources"; //$NON-NLS-1$ 4515 /** 4516 * <pre> 4517 * FORMATTER / Option to insert a space before unary operator 4518 * - option id: "org.eclipse.jdt.core.formatter.insert_space_before_unary_operator" 4519 * - possible values: { INSERT, DO_NOT_INSERT } 4520 * - default: DO_NOT_INSERT 4521 * </pre> 4522 * @see JavaCore#INSERT 4523 * @see JavaCore#DO_NOT_INSERT 4524 * @since 3.0 4525 */ 4526 public static final String FORMATTER_INSERT_SPACE_BEFORE_UNARY_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.insert_space_before_unary_operator"; //$NON-NLS-1$ 4527 4528 /** 4529 * <pre> 4530 * FORMATTER / Option to insert a space between brackets in an array type reference 4531 * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference" 4532 * - possible values: { INSERT, DO_NOT_INSERT } 4533 * - default: DO_NOT_INSERT 4534 * </pre> 4535 * @see JavaCore#INSERT 4536 * @see JavaCore#DO_NOT_INSERT 4537 * @since 3.0 4538 */ 4539 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$ 4540 /** 4541 * <pre> 4542 * FORMATTER / Option to insert a space between empty braces in an array initializer 4543 * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" 4544 * - possible values: { INSERT, DO_NOT_INSERT } 4545 * - default: DO_NOT_INSERT 4546 * </pre> 4547 * @see JavaCore#INSERT 4548 * @see JavaCore#DO_NOT_INSERT 4549 * @since 3.0 4550 */ 4551 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$ 4552 /** 4553 * <pre> 4554 * FORMATTER / Option to insert a space between empty brackets in an array allocation expression 4555 * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression" 4556 * - possible values: { INSERT, DO_NOT_INSERT } 4557 * - default: DO_NOT_INSERT 4558 * </pre> 4559 * @see JavaCore#INSERT 4560 * @see JavaCore#DO_NOT_INSERT 4561 * @since 3.0 4562 */ 4563 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$ 4564 /** 4565 * <pre> 4566 * FORMATTER / Option to insert a space between empty parenthesis in an annotation type member declaration 4567 * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration" 4568 * - possible values: { INSERT, DO_NOT_INSERT } 4569 * - default: DO_NOT_INSERT 4570 * </pre> 4571 * @see JavaCore#INSERT 4572 * @see JavaCore#DO_NOT_INSERT 4573 * @since 3.1 4574 */ 4575 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$ 4576 /** 4577 * <pre> 4578 * FORMATTER / Option to insert a space between empty parenthesis in a constructor declaration 4579 * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration" 4580 * - possible values: { INSERT, DO_NOT_INSERT } 4581 * - default: DO_NOT_INSERT 4582 * </pre> 4583 * @see JavaCore#INSERT 4584 * @see JavaCore#DO_NOT_INSERT 4585 * @since 3.0 4586 */ 4587 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$ 4588 /** 4589 * <pre> 4590 * FORMATTER / Option to insert a space between empty parenthesis in enum constant 4591 * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant" 4592 * - possible values: { INSERT, DO_NOT_INSERT } 4593 * - default: DO_NOT_INSERT 4594 * </pre> 4595 * @see JavaCore#INSERT 4596 * @see JavaCore#DO_NOT_INSERT 4597 * @since 3.1 4598 */ 4599 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$ 4600 /** 4601 * <pre> 4602 * FORMATTER / Option to insert a space between empty parenthesis in a method declaration 4603 * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" 4604 * - possible values: { INSERT, DO_NOT_INSERT } 4605 * - default: DO_NOT_INSERT 4606 * </pre> 4607 * @see JavaCore#INSERT 4608 * @see JavaCore#DO_NOT_INSERT 4609 * @since 3.0 4610 */ 4611 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$ 4612 /** 4613 * <pre> 4614 * FORMATTER / Option to insert a space between empty parenthesis in a method invocation 4615 * - option id: "org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation" 4616 * - possible values: { INSERT, DO_NOT_INSERT } 4617 * - default: DO_NOT_INSERT 4618 * </pre> 4619 * @see JavaCore#INSERT 4620 * @see JavaCore#DO_NOT_INSERT 4621 * @since 3.0 4622 */ 4623 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$ 4624 /** 4625 * <pre> 4626 * FORMATTER / Option to keep else statement on the same line 4627 * - option id: "org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line" 4628 * - possible values: { TRUE, FALSE } 4629 * - default: FALSE 4630 * </pre> 4631 * @see #TRUE 4632 * @see #FALSE 4633 * @since 3.0 4634 */ 4635 public static final String FORMATTER_KEEP_ELSE_STATEMENT_ON_SAME_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_else_statement_on_same_line"; //$NON-NLS-1$ 4636 /** 4637 * <pre> 4638 * FORMATTER / Option to keep empty array initializer one one line 4639 * - option id: "org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line" 4640 * - possible values: { TRUE, FALSE } 4641 * - default: FALSE 4642 * </pre> 4643 * @see #TRUE 4644 * @see #FALSE 4645 * @since 3.0 4646 */ 4647 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$ 4648 /** 4649 * <pre> 4650 * FORMATTER / Option to keep guardian clause on one line, in addition to the 4651 * #FORMATTER_KEEP_IF_THEN_BODY_BLOCK_ON_ONE_LINE option 4652 * - option id: "org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line" 4653 * - possible values: { TRUE, FALSE } 4654 * - default: FALSE 4655 * </pre> 4656 * @see #TRUE 4657 * @see #FALSE 4658 * @see #FORMATTER_KEEP_IF_THEN_BODY_BLOCK_ON_ONE_LINE 4659 * @since 3.0 4660 */ 4661 public static final String FORMATTER_KEEP_GUARDIAN_CLAUSE_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.format_guardian_clause_on_one_line"; //$NON-NLS-1$ 4662 /** 4663 * <pre> 4664 * FORMATTER / Option to keep simple if statement on the one line 4665 * - option id: "org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line" 4666 * - possible values: { TRUE, FALSE } 4667 * - default: FALSE 4668 * </pre> 4669 * @see #TRUE 4670 * @see #FALSE 4671 * @since 3.0 4672 */ 4673 public static final String FORMATTER_KEEP_SIMPLE_IF_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_imple_if_on_one_line"; //$NON-NLS-1$ 4674 /** 4675 * <pre> 4676 * FORMATTER / Option to keep then statement on the same line 4677 * - option id: "org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line" 4678 * - possible values: { TRUE, FALSE } 4679 * - default: FALSE 4680 * </pre> 4681 * @see #TRUE 4682 * @see #FALSE 4683 * @since 3.0 4684 */ 4685 public static final String FORMATTER_KEEP_THEN_STATEMENT_ON_SAME_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_then_statement_on_same_line";//$NON-NLS-1$ 4686 4687 /** 4688 * <pre> 4689 * FORMATTER / Option to keep a simple 'for' loop body on the same line 4690 * - option id: "org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line" 4691 * - possible values: { TRUE, FALSE } 4692 * - default: FALSE 4693 * </pre> 4694 * @see #TRUE 4695 * @see #FALSE 4696 * @since 3.15 4697 */ 4698 public static final String FORMATTER_KEEP_SIMPLE_FOR_BODY_ON_SAME_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_simple_for_body_on_same_line";//$NON-NLS-1$ 4699 /** 4700 * <pre> 4701 * FORMATTER / Option to keep a simple 'while' loop body on the same line 4702 * - option id: "org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line" 4703 * - possible values: { TRUE, FALSE } 4704 * - default: FALSE 4705 * </pre> 4706 * @see #TRUE 4707 * @see #FALSE 4708 * @since 3.15 4709 */ 4710 public static final String FORMATTER_KEEP_SIMPLE_WHILE_BODY_ON_SAME_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_simple_while_body_on_same_line";//$NON-NLS-1$ 4711 /** 4712 * <pre> 4713 * FORMATTER / Option to keep a simple 'do-while' loop body on the same line 4714 * - option id: "org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line" 4715 * - possible values: { TRUE, FALSE } 4716 * - default: FALSE 4717 * </pre> 4718 * @see #TRUE 4719 * @see #FALSE 4720 * @since 3.15 4721 */ 4722 public static final String FORMATTER_KEEP_SIMPLE_DO_WHILE_BODY_ON_SAME_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_simple_do_while_body_on_same_line";//$NON-NLS-1$ 4723 4724 /** 4725 * <pre> 4726 * FORMATTER / Option to control when a loop body block should be kept on one line 4727 * - option id: "org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line" 4728 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4729 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4730 * - default: ONE_LINE_NEVER 4731 * </pre> 4732 * @see #ONE_LINE_NEVER 4733 * @see #ONE_LINE_IF_EMPTY 4734 * @see #ONE_LINE_IF_SINGLE_ITEM 4735 * @see #ONE_LINE_ALWAYS 4736 * @see #ONE_LINE_PRESERVE 4737 * @since 3.16 4738 */ 4739 public static final String FORMATTER_KEEP_LOOP_BODY_BLOCK_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_loop_body_block_on_one_line"; //$NON-NLS-1$ 4740 /** 4741 * <pre> 4742 * FORMATTER / Option to control when an if-then statement body block should be kept on one line 4743 * - option id: "org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line" 4744 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4745 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4746 * - default: ONE_LINE_NEVER 4747 * </pre> 4748 * @see #ONE_LINE_NEVER 4749 * @see #ONE_LINE_IF_EMPTY 4750 * @see #ONE_LINE_IF_SINGLE_ITEM 4751 * @see #ONE_LINE_ALWAYS 4752 * @see #ONE_LINE_PRESERVE 4753 * @see #FORMATTER_KEEP_GUARDIAN_CLAUSE_ON_ONE_LINE for a special case 4754 * @since 3.16 4755 */ 4756 public static final String FORMATTER_KEEP_IF_THEN_BODY_BLOCK_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_if_then_body_block_on_one_line"; //$NON-NLS-1$ 4757 /** 4758 * <pre> 4759 * FORMATTER / Option to control when a code block other than if-then and loop body should 4760 * be kept on one line 4761 * - option id: "org.eclipse.jdt.core.formatter.keep_code_block_on_one_line" 4762 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY } 4763 * - default: ONE_LINE_NEVER 4764 * </pre> 4765 * @see #ONE_LINE_NEVER 4766 * @see #ONE_LINE_IF_EMPTY 4767 * @since 3.16 4768 */ 4769 public static final String FORMATTER_KEEP_CODE_BLOCK_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_code_block_on_one_line"; //$NON-NLS-1$ 4770 /** 4771 * <pre> 4772 * FORMATTER / Option to control when a method body should be kept on one line 4773 * - option id: "org.eclipse.jdt.core.formatter.keep_method_body_on_one_line" 4774 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4775 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4776 * - default: ONE_LINE_NEVER 4777 * </pre> 4778 * @see #ONE_LINE_NEVER 4779 * @see #ONE_LINE_IF_EMPTY 4780 * @see #ONE_LINE_IF_SINGLE_ITEM 4781 * @see #ONE_LINE_ALWAYS 4782 * @see #ONE_LINE_PRESERVE 4783 * @since 3.16 4784 */ 4785 public static final String FORMATTER_KEEP_METHOD_BODY_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_method_body_on_one_line"; //$NON-NLS-1$ 4786 /** 4787 * <pre> 4788 * FORMATTER / Option to control when a lambda body should be kept on one line 4789 * - option id: "org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line" 4790 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4791 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4792 * - default: ONE_LINE_NEVER 4793 * </pre> 4794 * @see #ONE_LINE_NEVER 4795 * @see #ONE_LINE_IF_EMPTY 4796 * @see #ONE_LINE_IF_SINGLE_ITEM 4797 * @see #ONE_LINE_ALWAYS 4798 * @see #ONE_LINE_PRESERVE 4799 * @since 3.16 4800 */ 4801 public static final String FORMATTER_KEEP_LAMBDA_BODY_BLOCK_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_lambda_body_block_on_one_line"; //$NON-NLS-1$ 4802 /** 4803 * <pre> 4804 * FORMATTER / Option to always keep simple getters and setters on one line, in addition to the 4805 * #FORMATTER_KEEP_METHOD_BODY_ON_ONE_LINE option 4806 * - option id: "org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line" 4807 * - possible values: { TRUE, FALSE } 4808 * - default: FALSE 4809 * </pre> 4810 * @see #TRUE 4811 * @see #FALSE 4812 * @see #FORMATTER_KEEP_METHOD_BODY_ON_ONE_LINE 4813 * @since 3.16 4814 */ 4815 public static final String FORMATTER_KEEP_SIMPLE_GETTER_SETTER_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_simple_getter_setter_on_one_line"; //$NON-NLS-1$ 4816 /** 4817 * <pre> 4818 * FORMATTER / Option to control when a type declaration should be kept on one line 4819 * - option id: "org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line" 4820 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4821 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4822 * - default: ONE_LINE_NEVER 4823 * </pre> 4824 * @see #ONE_LINE_NEVER 4825 * @see #ONE_LINE_IF_EMPTY 4826 * @see #ONE_LINE_IF_SINGLE_ITEM 4827 * @see #ONE_LINE_ALWAYS 4828 * @see #ONE_LINE_PRESERVE 4829 * @since 3.16 4830 * @since 3.0 4831 */ 4832 public static final String FORMATTER_KEEP_TYPE_DECLARATION_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_type_declaration_on_one_line"; //$NON-NLS-1$ 4833 /** 4834 * <pre> 4835 * FORMATTER / Option to control when an anonymous type declaration should be kept on one line 4836 * - option id: "org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line" 4837 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4838 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4839 * - default: ONE_LINE_NEVER 4840 * </pre> 4841 * @see #ONE_LINE_NEVER 4842 * @see #ONE_LINE_IF_EMPTY 4843 * @see #ONE_LINE_IF_SINGLE_ITEM 4844 * @see #ONE_LINE_ALWAYS 4845 * @see #ONE_LINE_PRESERVE 4846 * @since 3.16 4847 */ 4848 public static final String FORMATTER_KEEP_ANONYMOUS_TYPE_DECLARATION_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_anonymous_type_declaration_on_one_line"; //$NON-NLS-1$ 4849 /** 4850 * <pre> 4851 * FORMATTER / Option to control when an enum constant declaration body should be kept on one line 4852 * - option id: "org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line" 4853 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4854 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4855 * - default: ONE_LINE_NEVER 4856 * </pre> 4857 * @see #ONE_LINE_NEVER 4858 * @see #ONE_LINE_IF_EMPTY 4859 * @see #ONE_LINE_IF_SINGLE_ITEM 4860 * @see #ONE_LINE_ALWAYS 4861 * @see #ONE_LINE_PRESERVE 4862 * @since 3.16 4863 */ 4864 public static final String FORMATTER_KEEP_ENUM_CONSTANT_DECLARATION_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_enum_constant_declaration_on_one_line"; //$NON-NLS-1$ 4865 /** 4866 * <pre> 4867 * FORMATTER / Option to control when an enum declaration should be kept on one line 4868 * - option id: "org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line" 4869 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4870 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4871 * - default: ONE_LINE_NEVER 4872 * </pre> 4873 * @see #ONE_LINE_NEVER 4874 * @see #ONE_LINE_IF_EMPTY 4875 * @see #ONE_LINE_IF_SINGLE_ITEM 4876 * @see #ONE_LINE_ALWAYS 4877 * @see #ONE_LINE_PRESERVE 4878 * @since 3.16 4879 */ 4880 public static final String FORMATTER_KEEP_ENUM_DECLARATION_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_enum_declaration_on_one_line"; //$NON-NLS-1$ 4881 /** 4882 * <pre> 4883 * FORMATTER / Option to control when an annotation declaration should be kept on one line 4884 * - option id: "org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line" 4885 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4886 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4887 * - default: ONE_LINE_NEVER 4888 * </pre> 4889 * @see #ONE_LINE_NEVER 4890 * @see #ONE_LINE_IF_EMPTY 4891 * @see #ONE_LINE_IF_SINGLE_ITEM 4892 * @see #ONE_LINE_ALWAYS 4893 * @see #ONE_LINE_PRESERVE 4894 * @since 3.16 4895 */ 4896 public static final String FORMATTER_KEEP_ANNOTATION_DECLARATION_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_annotation_declaration_on_one_line"; //$NON-NLS-1$ 4897 /** 4898 * <pre> 4899 * FORMATTER / Option to control when a record declaration should be kept on one line 4900 * - option id: "org.eclipse.jdt.core.formatter.keep_record_declaration_on_one_line" 4901 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4902 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4903 * - default: ONE_LINE_NEVER 4904 * </pre> 4905 * @see #ONE_LINE_NEVER 4906 * @see #ONE_LINE_IF_EMPTY 4907 * @see #ONE_LINE_IF_SINGLE_ITEM 4908 * @see #ONE_LINE_ALWAYS 4909 * @see #ONE_LINE_PRESERVE 4910 * @since 3.22 4911 */ 4912 public static final String FORMATTER_KEEP_RECORD_DECLARATION_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_record_declaration_on_one_line"; //$NON-NLS-1$ 4913 /** 4914 * <pre> 4915 * FORMATTER / Option to control when a record constructor should be kept on one line 4916 * - option id: "org.eclipse.jdt.core.formatter.keep_record_constructor_on_one_line" 4917 * - possible values: { ONE_LINE_NEVER, ONE_LINE_IF_EMPTY, ONE_LINE_IF_SINGLE_ITEM, 4918 * ONE_LINE_ALWAYS, ONE_LINE_PRESERVE } 4919 * - default: ONE_LINE_NEVER 4920 * </pre> 4921 * @see #ONE_LINE_NEVER 4922 * @see #ONE_LINE_IF_EMPTY 4923 * @see #ONE_LINE_IF_SINGLE_ITEM 4924 * @see #ONE_LINE_ALWAYS 4925 * @see #ONE_LINE_PRESERVE 4926 * @since 3.22 4927 */ 4928 public static final String FORMATTER_KEEP_RECORD_CONSTRUCTOR_ON_ONE_LINE = JavaCore.PLUGIN_ID + ".formatter.keep_record_constructor_on_one_line"; //$NON-NLS-1$ 4929 4930 /** 4931 * <pre> 4932 * FORMATTER / Option to specify the length of the page. Beyond this length, the formatter will try to split the code 4933 * - option id: "org.eclipse.jdt.core.formatter.lineSplit" 4934 * - possible values: "<n>", where n is zero or a positive integer 4935 * - default: "120" 4936 * </pre> 4937 * @since 3.0 4938 */ 4939 public static final String FORMATTER_LINE_SPLIT = JavaCore.PLUGIN_ID + ".formatter.lineSplit"; //$NON-NLS-1$ 4940 /** 4941 * <pre> 4942 * FORMATTER / Option to indent block comments that start on the first column 4943 * - option id: "org.eclipse.jdt.core.formatter.formatter.never_indent_block_comments_on_first_column" 4944 * - possible values: { TRUE, FALSE } 4945 * - default: FALSE 4946 * </pre> 4947 * Note that this option is ignored if the formatter is created with the mode {@link ToolFactory#M_FORMAT_NEW}. 4948 * @see #TRUE 4949 * @see #FALSE 4950 * @see ToolFactory#createCodeFormatter(Map, int) 4951 * @since 3.3 4952 */ 4953 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$ 4954 /** 4955 * <pre> 4956 * FORMATTER / Option to indent line comments that start on the first column 4957 * - option id: "org.eclipse.jdt.core.formatter.formatter.never_indent_line_comments_on_first_column" 4958 * - possible values: { TRUE, FALSE } 4959 * - default: FALSE 4960 * </pre> 4961 * Note that: 4962 * <ul> 4963 * <li>this option is ignored if the formatter is created with the mode {@link ToolFactory#M_FORMAT_NEW}</li> 4964 * <li>even with this option activated, the formatter still can ignore line comments starting at first column 4965 * if the option {@link #FORMATTER_COMMENT_FORMAT_LINE_COMMENT_STARTING_ON_FIRST_COLUMN} is set to {@value #FALSE}</li> 4966 * </ul> 4967 * @see #TRUE 4968 * @see #FALSE 4969 * @see ToolFactory#createCodeFormatter(Map, int) 4970 * @since 3.3 4971 */ 4972 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$ 4973 /** 4974 * <pre> 4975 * FORMATTER / Option to specify the number of empty lines to preserve 4976 * - option id: "org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve" 4977 * - possible values: "<n>", where n is zero or a positive integer 4978 * - default: "0" 4979 * </pre> 4980 * @since 3.0 4981 */ 4982 public static final String FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE = JavaCore.PLUGIN_ID + ".formatter.number_of_empty_lines_to_preserve"; //$NON-NLS-1$ 4983 /** 4984 * <pre> 4985 * FORMATTER / Option to specify whether the formatter can join wrapped lines or not 4986 * 4987 * For example, the wrapped lines of method foo return statement in following test case: 4988 * class X { 4989 * String foo() { 4990 * return "select x " 4991 * + "from y " 4992 * + "where z=a"; 4993 * } 4994 * } 4995 * 4996 * will be preserved by the formatter when the new preference is used 4997 * even if the maximum line width would give it enough space to join the lines. 4998 * Hence produces the following output: 4999 * class X { 5000 * String foo() { 5001 * return "select x " 5002 * + "from y " 5003 * + "where z=a"; 5004 * } 5005 * } 5006 * 5007 * - option id: "org.eclipse.jdt.core.formatter.join_wrapped_lines" 5008 * - possible values: { TRUE, FALSE } 5009 * - default: TRUE 5010 * </pre> 5011 * @since 3.5 5012 */ 5013 public static final String FORMATTER_JOIN_WRAPPED_LINES = JavaCore.PLUGIN_ID + ".formatter.join_wrapped_lines"; //$NON-NLS-1$ 5014 /** 5015 * <pre> 5016 * FORMATTER / Option to specify whether the formatter can join text lines in comments or not 5017 * 5018 * For example, the following comment: 5019 * /** 5020 * * The foo method. 5021 * * foo is a substitute for bar. 5022 * */ 5023 * public class X { 5024 * } 5025 * 5026 * will be unchanged by the formatter when this new preference is used, 5027 * even if the maximum line width would give it enough space to join the lines. 5028 * 5029 * - option id: "org.eclipse.jdt.core.formatter.join_lines_in_comments" 5030 * - possible values: { TRUE, FALSE } 5031 * - default: TRUE 5032 * </pre> 5033 * @since 3.5 5034 */ 5035 public static final String FORMATTER_JOIN_LINES_IN_COMMENTS = JavaCore.PLUGIN_ID + ".formatter.join_lines_in_comments"; //$NON-NLS-1$ 5036 /** 5037 * <pre> 5038 * FORMATTER / Option to specify whether or not empty statement should be on a new line 5039 * - option id: "org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line" 5040 * - possible values: { TRUE, FALSE } 5041 * - default: FALSE 5042 * </pre> 5043 * @see #TRUE 5044 * @see #FALSE 5045 * @since 3.0 5046 */ 5047 public static final String FORMATTER_PUT_EMPTY_STATEMENT_ON_NEW_LINE = JavaCore.PLUGIN_ID + ".formatter.put_empty_statement_on_new_line"; //$NON-NLS-1$ 5048 /** 5049 * <pre> 5050 * FORMATTER / Option to specify the tabulation size 5051 * - option id: "org.eclipse.jdt.core.formatter.tabulation.char" 5052 * - possible values: { TAB, SPACE, MIXED } 5053 * - default: TAB 5054 * </pre> 5055 * More values may be added in the future. 5056 * 5057 * @see JavaCore#TAB 5058 * @see JavaCore#SPACE 5059 * @see #MIXED 5060 * @since 3.0 5061 */ 5062 public static final String FORMATTER_TAB_CHAR = JavaCore.PLUGIN_ID + ".formatter.tabulation.char"; //$NON-NLS-1$ 5063 /** 5064 * <pre> 5065 * FORMATTER / Option to specify the equivalent number of spaces that represents one tabulation 5066 * - option id: "org.eclipse.jdt.core.formatter.tabulation.size" 5067 * - possible values: "<n>", where n is zero or a positive integer 5068 * - default: "4" 5069 * </pre> 5070 * @since 3.0 5071 */ 5072 public static final String FORMATTER_TAB_SIZE = JavaCore.PLUGIN_ID + ".formatter.tabulation.size"; //$NON-NLS-1$ 5073 5074 /** 5075 * <pre> 5076 * FORMATTER / Option to use tabulations for indentation and spaces for line wrapping 5077 * - option id: "org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations" 5078 * - possible values: { TRUE, FALSE } 5079 * - default: FALSE 5080 * </pre> 5081 * @see #TRUE 5082 * @see #FALSE 5083 * @since 3.1 5084 */ 5085 public static final String FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS = JavaCore.PLUGIN_ID + ".formatter.use_tabs_only_for_leading_indentations"; //$NON-NLS-1$ 5086 5087 /** 5088 * <pre> 5089 * FORMATTER / Option to wrap before the multiplicative operator (*, /, %) 5090 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator" 5091 * - possible values: { TRUE, FALSE } 5092 * - default: TRUE 5093 * </pre> 5094 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_MULTIPLE_FIELDS} is set. 5095 * @see #TRUE 5096 * @see #FALSE 5097 * @since 3.17 5098 */ 5099 public static final String FORMATTER_WRAP_BEFORE_MULTIPLICATIVE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.wrap_before_multiplicative_operator"; //$NON-NLS-1$ 5100 /** 5101 * <pre> 5102 * FORMATTER / Option to wrap before the additive operator (+, -) 5103 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_additive_operator" 5104 * - possible values: { TRUE, FALSE } 5105 * - default: TRUE 5106 * </pre> 5107 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_ADDITIVE_OPERATOR} is set. 5108 * @see #TRUE 5109 * @see #FALSE 5110 * @since 3.17 5111 */ 5112 public static final String FORMATTER_WRAP_BEFORE_ADDITIVE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.wrap_before_additive_operator"; //$NON-NLS-1$ 5113 /** 5114 * <pre> 5115 * FORMATTER / Option to wrap before the string concatenation operator 5116 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_string_concatenation" 5117 * - possible values: { TRUE, FALSE } 5118 * - default: TRUE 5119 * </pre> 5120 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_STRING_CONCATENATION} is set. 5121 * @see #TRUE 5122 * @see #FALSE 5123 * @since 3.17 5124 */ 5125 public static final String FORMATTER_WRAP_BEFORE_STRING_CONCATENATION = JavaCore.PLUGIN_ID + ".formatter.wrap_before_string_concatenation"; //$NON-NLS-1$ 5126 /** 5127 * <pre> 5128 * FORMATTER / Option to wrap before the shift operator (<<, >>, >>>) 5129 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_shift_operator" 5130 * - possible values: { TRUE, FALSE } 5131 * - default: TRUE 5132 * </pre> 5133 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_SHIFT_OPERATOR} is set. 5134 * @see #TRUE 5135 * @see #FALSE 5136 * @since 3.17 5137 */ 5138 public static final String FORMATTER_WRAP_BEFORE_SHIFT_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.wrap_before_shift_operator"; //$NON-NLS-1$ 5139 /** 5140 * <pre> 5141 * FORMATTER / Option to wrap before the relational operator (<, >, <=, >=, ==, !=) 5142 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_" 5143 * - possible values: { TRUE, FALSE } 5144 * - default: TRUE 5145 * </pre> 5146 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_RELATIONAL_OPERATOR} is set. 5147 * @see #TRUE 5148 * @see #FALSE 5149 * @since 3.17 5150 */ 5151 public static final String FORMATTER_WRAP_BEFORE_RELATIONAL_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.wrap_before_relational_operator"; //$NON-NLS-1$ 5152 /** 5153 * <pre> 5154 * FORMATTER / Option to wrap before the bitwise operator (&, ^, |) 5155 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator" 5156 * - possible values: { TRUE, FALSE } 5157 * - default: TRUE 5158 * </pre> 5159 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_BITWISE_OPERATOR} is set. 5160 * @see #TRUE 5161 * @see #FALSE 5162 * @since 3.17 5163 */ 5164 public static final String FORMATTER_WRAP_BEFORE_BITWISE_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.wrap_before_bitwise_operator"; //$NON-NLS-1$ 5165 /** 5166 * <pre> 5167 * FORMATTER / Option to wrap before the logical operator (&&, ||) 5168 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_logical_operator" 5169 * - possible values: { TRUE, FALSE } 5170 * - default: TRUE 5171 * </pre> 5172 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_LOGICAL_OPERATOR} is set. 5173 * @see #TRUE 5174 * @see #FALSE 5175 * @since 3.17 5176 */ 5177 public static final String FORMATTER_WRAP_BEFORE_LOGICAL_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.wrap_before_logical_operator"; //$NON-NLS-1$ 5178 /** 5179 * <pre> 5180 * FORMATTER / Option to wrap before the binary operator 5181 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_binary_operator" 5182 * - possible values: { TRUE, FALSE } 5183 * - default: TRUE 5184 * </pre> 5185 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_BINARY_EXPRESSION} is set. 5186 * @see #TRUE 5187 * @see #FALSE 5188 * @since 3.3 5189 * @deprecated Use the new options instead: {@link #FORMATTER_WRAP_BEFORE_MULTIPLICATIVE_OPERATOR}, 5190 * {@link #FORMATTER_WRAP_BEFORE_ADDITIVE_OPERATOR}, {@link #FORMATTER_WRAP_BEFORE_STRING_CONCATENATION}, 5191 * {@link #FORMATTER_WRAP_BEFORE_BITWISE_OPERATOR}, {@link #FORMATTER_WRAP_BEFORE_LOGICAL_OPERATOR} 5192 */ 5193 public static final String FORMATTER_WRAP_BEFORE_BINARY_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.wrap_before_binary_operator"; //$NON-NLS-1$ 5194 /** 5195 * <pre> 5196 * FORMATTER / Option to wrap before the '|' operator in multi-catch statements 5197 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch" 5198 * - possible values: { TRUE, FALSE } 5199 * - default: TRUE 5200 * </pre> 5201 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_UNION_TYPE_IN_MULTICATCH} is set. 5202 * @see #TRUE 5203 * @see #FALSE 5204 * @since 3.7.1 5205 */ 5206 public static final String FORMATTER_WRAP_BEFORE_OR_OPERATOR_MULTICATCH = JavaCore.PLUGIN_ID + ".formatter.wrap_before_or_operator_multicatch"; //$NON-NLS-1$ 5207 /** 5208 * <pre> 5209 * FORMATTER / Option to wrap before the '?' and ':' operators in conditional expressions 5210 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_conditional_operator" 5211 * - possible values: { TRUE, FALSE } 5212 * - default: TRUE 5213 * </pre> 5214 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_CONDITIONAL_EXPRESSION} is set. 5215 * @see #TRUE 5216 * @see #FALSE 5217 * @since 3.12 5218 */ 5219 public static final String FORMATTER_WRAP_BEFORE_CONDITIONAL_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.wrap_before_conditional_operator"; //$NON-NLS-1$ 5220 /** 5221 * <pre> 5222 * FORMATTER / Option to wrap before the assignment operator 5223 * - option id: "org.eclipse.jdt.core.formatter.wrap_before_assignment_operator" 5224 * - possible values: { TRUE, FALSE } 5225 * - default: TRUE 5226 * </pre> 5227 * This option is used only if the option {@link #FORMATTER_ALIGNMENT_FOR_ASSIGNMENT} is set. 5228 * @see #TRUE 5229 * @see #FALSE 5230 * @since 3.12 5231 */ 5232 public static final String FORMATTER_WRAP_BEFORE_ASSIGNMENT_OPERATOR = JavaCore.PLUGIN_ID + ".formatter.wrap_before_assignment_operator"; //$NON-NLS-1$ 5233 /** 5234 * <pre> 5235 * FORMATTER / Option to wrap outer expressions in nested expressions 5236 * - option id: "org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested" 5237 * - possible values: { TRUE, FALSE } 5238 * - default: TRUE 5239 * </pre> 5240 * <p> 5241 * This option changes the formatter behavior when nested method calls are encountered. 5242 * Since 3.6, the formatter tries to wrap outermost method calls first to have a better output.</p> 5243 * <p>For example, let's say we are using the Eclipse built-in profile with a max line width=40+space for tab policy. 5244 * Then consider the following snippet:</p> 5245 * <pre> 5246 * public class X01 { 5247 * void test() { 5248 * foo(bar(1, 2, 3, 4), bar(5, 6, 7, 8)); 5249 * } 5250 * } 5251 * </pre> 5252 * <p>With this new strategy, the formatter will wrap the line earlier, between the arguments of the message call 5253 * for this example, and then it will allow to keep each nested call on a single line.</p> 5254 * <p>Hence, the output will be:</p> 5255 * <pre> 5256 * public class X01 { 5257 * void test() { 5258 * foo(bar(1, 2, 3, 4), 5259 * bar(5, 6, 7, 8)); 5260 * } 5261 * } 5262 * </pre> 5263 * <p><b><u>Important notes</u></b>:</p> 5264 * <ol> 5265 * <li>This new behavior is automatically activated (i.e. the default value for this preference is {@link #TRUE}). 5266 * If the backward compatibility regarding previous versions' formatter behavior (i.e. before 3.6 version) is necessary, 5267 * then the preference needs to be set to {@link #FALSE} to retrieve the previous formatter behavior.</li> 5268 * <li>The new strategy currently only applies to nested method calls, but might be extended to other nested expressions in future versions</li> 5269 * </ol> 5270 * 5271 * @see #TRUE 5272 * @see #FALSE 5273 * @since 3.6 5274 */ 5275 public static final String FORMATTER_WRAP_OUTER_EXPRESSIONS_WHEN_NESTED = JavaCore.PLUGIN_ID + ".formatter.wrap_outer_expressions_when_nested"; //$NON-NLS-1$ 5276 /** 5277 * <pre> 5278 * FORMATTER / The wrapping is done by indenting by one compare to the current indentation. 5279 * </pre> 5280 * @since 3.0 5281 */ 5282 public static final int INDENT_BY_ONE= 2; 5283 5284 /** 5285 * <pre> 5286 * FORMATTER / The wrapping is done by using the current indentation. 5287 * </pre> 5288 * @since 3.0 5289 */ 5290 public static final int INDENT_DEFAULT= 0; 5291 /** 5292 * <pre> 5293 * FORMATTER / The wrapping is done by indenting on column under the splitting location. 5294 * </pre> 5295 * @since 3.0 5296 */ 5297 public static final int INDENT_ON_COLUMN = 1; 5298 /** 5299 * <pre> 5300 * FORMATTER / Indentation is not touched, it's preserved from original source. 5301 * </pre> 5302 * @since 3.20 5303 */ 5304 public static final int INDENT_PRESERVE = 3; 5305 5306 /** 5307 * <pre> 5308 * FORMATTER / Possible value for the option FORMATTER_TAB_CHAR 5309 * </pre> 5310 * @since 3.1 5311 * @see JavaCore#TAB 5312 * @see JavaCore#SPACE 5313 * @see #FORMATTER_TAB_CHAR 5314 */ 5315 public static final String MIXED = "mixed"; //$NON-NLS-1$ 5316 /** 5317 * <pre> 5318 * FORMATTER / Value to set a brace location at the start of the next line with 5319 * the right indentation. 5320 * </pre> 5321 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION 5322 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER 5323 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK 5324 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION 5325 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION 5326 * @see #FORMATTER_BRACE_POSITION_FOR_RECORD_CONSTRUCTOR 5327 * @see #FORMATTER_BRACE_POSITION_FOR_RECORD_DECLARATION 5328 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH 5329 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION 5330 * @see #FORMATTER_BRACE_POSITION_FOR_LAMBDA_BODY 5331 * @since 3.0 5332 */ 5333 public static final String NEXT_LINE = "next_line"; //$NON-NLS-1$ 5334 /** 5335 * <pre> 5336 * FORMATTER / Value to set a brace location at the start of the next line if a wrapping 5337 * occured. 5338 * </pre> 5339 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION 5340 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER 5341 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK 5342 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION 5343 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION 5344 * @see #FORMATTER_BRACE_POSITION_FOR_RECORD_CONSTRUCTOR 5345 * @see #FORMATTER_BRACE_POSITION_FOR_RECORD_DECLARATION 5346 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH 5347 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION 5348 * @see #FORMATTER_BRACE_POSITION_FOR_LAMBDA_BODY 5349 * @since 3.0 5350 */ 5351 public static final String NEXT_LINE_ON_WRAP = "next_line_on_wrap"; //$NON-NLS-1$ 5352 /** 5353 * <pre> 5354 * FORMATTER / Value to set a brace location at the start of the next line with 5355 * an extra indentation. 5356 * </pre> 5357 * @see #FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION 5358 * @see #FORMATTER_BRACE_POSITION_FOR_ARRAY_INITIALIZER 5359 * @see #FORMATTER_BRACE_POSITION_FOR_BLOCK 5360 * @see #FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION 5361 * @see #FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION 5362 * @see #FORMATTER_BRACE_POSITION_FOR_RECORD_CONSTRUCTOR 5363 * @see #FORMATTER_BRACE_POSITION_FOR_RECORD_DECLARATION 5364 * @see #FORMATTER_BRACE_POSITION_FOR_SWITCH 5365 * @see #FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION 5366 * @see #FORMATTER_BRACE_POSITION_FOR_LAMBDA_BODY 5367 * @since 3.0 5368 */ 5369 public static final String NEXT_LINE_SHIFTED = "next_line_shifted"; //$NON-NLS-1$ 5370 5371 /** 5372 * <pre> 5373 * FORMATTER / Value to set opening and closing parentheses location in common lines with 5374 * their contents (or simply a single line if the parentheses are empty). 5375 * </pre> 5376 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_DECLARATION 5377 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_INVOCATION 5378 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_ENUM_CONSTANT_DECLARATION 5379 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_RECORD_DECLARATION 5380 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_IF_WHILE_STATEMENT 5381 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_FOR_STATEMENT 5382 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_SWITCH_STATEMENT 5383 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_TRY_CLAUSE 5384 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_CATCH_CLAUSE 5385 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_ANNOTATION 5386 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_LAMBDA_DECLARATION 5387 * @since 3.12 5388 */ 5389 public static final String COMMON_LINES = "common_lines"; //$NON-NLS-1$ 5390 5391 /** 5392 * <pre> 5393 * FORMATTER / Value to set opening and closing parentheses location on a common line 5394 * if the parentheses are empty and otherwise in separate lines from their contents. 5395 * </pre> 5396 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_DECLARATION 5397 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_INVOCATION 5398 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_ENUM_CONSTANT_DECLARATION 5399 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_RECORD_DECLARATION 5400 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_ANNOTATION 5401 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_LAMBDA_DECLARATION 5402 * @since 3.12 5403 */ 5404 public static final String SEPARATE_LINES_IF_NOT_EMPTY = "separate_lines_if_not_empty"; //$NON-NLS-1$ 5405 5406 /** 5407 * <pre> 5408 * FORMATTER / Value to set opening and closing parentheses location on separate lines from their 5409 * contents if the contents are wrapped, and in common line if they fit in line width. 5410 * </pre> 5411 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_DECLARATION 5412 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_INVOCATION 5413 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_ENUM_CONSTANT_DECLARATION 5414 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_RECORD_DECLARATION 5415 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_IF_WHILE_STATEMENT 5416 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_FOR_STATEMENT 5417 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_SWITCH_STATEMENT 5418 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_TRY_CLAUSE 5419 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_CATCH_CLAUSE 5420 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_ANNOTATION 5421 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_LAMBDA_DECLARATION 5422 * @since 3.12 5423 */ 5424 public static final String SEPARATE_LINES_IF_WRAPPED = "separate_lines_if_wrapped"; //$NON-NLS-1$ 5425 5426 /** 5427 * <pre> 5428 * FORMATTER / Value to set parentheses location on separate lines from their contents, 5429 * that is put a line break after the opening parenthesis and before 5430 * the closing parenthesis. 5431 * </pre> 5432 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_DECLARATION 5433 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_INVOCATION 5434 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_ENUM_CONSTANT_DECLARATION 5435 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_RECORD_DECLARATION 5436 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_IF_WHILE_STATEMENT 5437 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_FOR_STATEMENT 5438 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_SWITCH_STATEMENT 5439 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_TRY_CLAUSE 5440 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_CATCH_CLAUSE 5441 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_ANNOTATION 5442 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_LAMBDA_DECLARATION 5443 * @since 3.12 5444 */ 5445 public static final String SEPARATE_LINES = "separate_lines"; //$NON-NLS-1$ 5446 5447 /** 5448 * <pre> 5449 * FORMATTER / Value to set opening and closing parentheses location to be preserved 5450 * from the original source. 5451 * </pre> 5452 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_DECLARATION 5453 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_METHOD_INVOCATION 5454 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_ENUM_CONSTANT_DECLARATION 5455 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_RECORD_DECLARATION 5456 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_IF_WHILE_STATEMENT 5457 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_FOR_STATEMENT 5458 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_SWITCH_STATEMENT 5459 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_TRY_CLAUSE 5460 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_CATCH_CLAUSE 5461 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_ANNOTATION 5462 * @see #FORMATTER_PARENTHESES_POSITIONS_IN_LAMBDA_DECLARATION 5463 * @since 3.12 5464 */ 5465 public static final String PRESERVE_POSITIONS = "preserve_positions"; //$NON-NLS-1$ 5466 5467 /** 5468 * <pre> 5469 * FORMATTER / Value to never keep braced code on one line. 5470 * </pre> 5471 * @see #FORMATTER_KEEP_LOOP_BODY_BLOCK_ON_ONE_LINE 5472 * @see #FORMATTER_KEEP_IF_THEN_BODY_BLOCK_ON_ONE_LINE 5473 * @see #FORMATTER_KEEP_CODE_BLOCK_ON_ONE_LINE 5474 * @see #FORMATTER_KEEP_METHOD_BODY_ON_ONE_LINE 5475 * @see #FORMATTER_KEEP_LAMBDA_BODY_BLOCK_ON_ONE_LINE 5476 * @see #FORMATTER_KEEP_TYPE_DECLARATION_ON_ONE_LINE 5477 * @see #FORMATTER_KEEP_ANONYMOUS_TYPE_DECLARATION_ON_ONE_LINE 5478 * @see #FORMATTER_KEEP_ENUM_CONSTANT_DECLARATION_ON_ONE_LINE 5479 * @see #FORMATTER_KEEP_ENUM_DECLARATION_ON_ONE_LINE 5480 * @see #FORMATTER_KEEP_ANNOTATION_DECLARATION_ON_ONE_LINE 5481 * @since 3.16 5482 */ 5483 public static final String ONE_LINE_NEVER = "one_line_never"; //$NON-NLS-1$ 5484 /** 5485 * <pre> 5486 * FORMATTER / Value to keep braced code on one line only if it's empty. 5487 * </pre> 5488 * @see #FORMATTER_KEEP_LOOP_BODY_BLOCK_ON_ONE_LINE 5489 * @see #FORMATTER_KEEP_IF_THEN_BODY_BLOCK_ON_ONE_LINE 5490 * @see #FORMATTER_KEEP_CODE_BLOCK_ON_ONE_LINE 5491 * @see #FORMATTER_KEEP_METHOD_BODY_ON_ONE_LINE 5492 * @see #FORMATTER_KEEP_LAMBDA_BODY_BLOCK_ON_ONE_LINE 5493 * @see #FORMATTER_KEEP_TYPE_DECLARATION_ON_ONE_LINE 5494 * @see #FORMATTER_KEEP_ANONYMOUS_TYPE_DECLARATION_ON_ONE_LINE 5495 * @see #FORMATTER_KEEP_ENUM_CONSTANT_DECLARATION_ON_ONE_LINE 5496 * @see #FORMATTER_KEEP_ENUM_DECLARATION_ON_ONE_LINE 5497 * @see #FORMATTER_KEEP_ANNOTATION_DECLARATION_ON_ONE_LINE 5498 * @since 3.16 5499 */ 5500 public static final String ONE_LINE_IF_EMPTY = "one_line_if_empty"; //$NON-NLS-1$ 5501 /** 5502 * <pre> 5503 * FORMATTER / Value to keep braced code on one line if it contains at most a single 5504 * item. 5505 * </pre> 5506 * @see #FORMATTER_KEEP_LOOP_BODY_BLOCK_ON_ONE_LINE 5507 * @see #FORMATTER_KEEP_IF_THEN_BODY_BLOCK_ON_ONE_LINE 5508 * @see #FORMATTER_KEEP_METHOD_BODY_ON_ONE_LINE 5509 * @see #FORMATTER_KEEP_LAMBDA_BODY_BLOCK_ON_ONE_LINE 5510 * @see #FORMATTER_KEEP_TYPE_DECLARATION_ON_ONE_LINE 5511 * @see #FORMATTER_KEEP_ANONYMOUS_TYPE_DECLARATION_ON_ONE_LINE 5512 * @see #FORMATTER_KEEP_ENUM_CONSTANT_DECLARATION_ON_ONE_LINE 5513 * @see #FORMATTER_KEEP_ENUM_DECLARATION_ON_ONE_LINE 5514 * @see #FORMATTER_KEEP_ANNOTATION_DECLARATION_ON_ONE_LINE 5515 * @since 3.16 5516 */ 5517 public static final String ONE_LINE_IF_SINGLE_ITEM = "one_line_if_single_item"; //$NON-NLS-1$ 5518 /** 5519 * <pre> 5520 * FORMATTER / Value to always keep braced code on one line, as long as it doesn't 5521 * exceed the line width limit. 5522 * </pre> 5523 * @see #FORMATTER_KEEP_LOOP_BODY_BLOCK_ON_ONE_LINE 5524 * @see #FORMATTER_KEEP_IF_THEN_BODY_BLOCK_ON_ONE_LINE 5525 * @see #FORMATTER_KEEP_METHOD_BODY_ON_ONE_LINE 5526 * @see #FORMATTER_KEEP_LAMBDA_BODY_BLOCK_ON_ONE_LINE 5527 * @see #FORMATTER_KEEP_TYPE_DECLARATION_ON_ONE_LINE 5528 * @see #FORMATTER_KEEP_ANONYMOUS_TYPE_DECLARATION_ON_ONE_LINE 5529 * @see #FORMATTER_KEEP_ENUM_CONSTANT_DECLARATION_ON_ONE_LINE 5530 * @see #FORMATTER_KEEP_ENUM_DECLARATION_ON_ONE_LINE 5531 * @see #FORMATTER_KEEP_ANNOTATION_DECLARATION_ON_ONE_LINE 5532 * @since 3.16 5533 */ 5534 public static final String ONE_LINE_ALWAYS = "one_line_always"; //$NON-NLS-1$ 5535 /** 5536 * <pre> 5537 * FORMATTER / Value to keep braced code on one line as long as it doesn't exceed the 5538 * line width limit and it was already in one line in the original source. 5539 * </pre> 5540 * @see #FORMATTER_KEEP_LOOP_BODY_BLOCK_ON_ONE_LINE 5541 * @see #FORMATTER_KEEP_IF_THEN_BODY_BLOCK_ON_ONE_LINE 5542 * @see #FORMATTER_KEEP_METHOD_BODY_ON_ONE_LINE 5543 * @see #FORMATTER_KEEP_LAMBDA_BODY_BLOCK_ON_ONE_LINE 5544 * @see #FORMATTER_KEEP_TYPE_DECLARATION_ON_ONE_LINE 5545 * @see #FORMATTER_KEEP_ANONYMOUS_TYPE_DECLARATION_ON_ONE_LINE 5546 * @see #FORMATTER_KEEP_ENUM_CONSTANT_DECLARATION_ON_ONE_LINE 5547 * @see #FORMATTER_KEEP_ENUM_DECLARATION_ON_ONE_LINE 5548 * @see #FORMATTER_KEEP_ANNOTATION_DECLARATION_ON_ONE_LINE 5549 * @since 3.16 5550 */ 5551 public static final String ONE_LINE_PRESERVE = "one_line_preserve"; //$NON-NLS-1$ 5552 5553 /** 5554 * <pre> 5555 * FORMATTER / Value to set an option to true. 5556 * </pre> 5557 * @since 3.0 5558 */ 5559 public static final String TRUE = "true"; //$NON-NLS-1$ 5560 /** 5561 * <pre> 5562 * FORMATTER / The wrapping is done using as few lines as possible. 5563 * </pre> 5564 * @since 3.0 5565 */ 5566 public static final int WRAP_COMPACT= 1; 5567 /** 5568 * <pre> 5569 * FORMATTER / The wrapping is done putting the first element on a new 5570 * line and then wrapping next elements using as few lines as possible. 5571 * </pre> 5572 * @since 3.0 5573 */ 5574 public static final int WRAP_COMPACT_FIRST_BREAK= 2; 5575 /** 5576 * <pre> 5577 * FORMATTER / The wrapping is done by putting each element on its own line 5578 * except the first element. 5579 * </pre> 5580 * @since 3.0 5581 */ 5582 public static final int WRAP_NEXT_PER_LINE= 5; 5583 /** 5584 * <pre> 5585 * FORMATTER / The wrapping is done by putting each element on its own line. 5586 * All elements are indented by one except the first element. 5587 * </pre> 5588 * @since 3.0 5589 */ 5590 public static final int WRAP_NEXT_SHIFTED= 4; 5591 5592 /** 5593 * <pre> 5594 * FORMATTER / Value to disable alignment. 5595 * </pre> 5596 * @since 3.0 5597 */ 5598 public static final int WRAP_NO_SPLIT= 0; 5599 /** 5600 * <pre> 5601 * FORMATTER / The wrapping is done by putting each element on its own line. 5602 * </pre> 5603 * @since 3.0 5604 */ 5605 public static final int WRAP_ONE_PER_LINE= 3; 5606 5607 /** 5608 * Create a new alignment value according to the given values. This must be used to set up 5609 * the alignment options. 5610 * 5611 * @param forceSplit the given force value 5612 * @param wrapStyle the given wrapping style 5613 * @param indentStyle the given indent style 5614 * 5615 * @return the new alignment value 5616 */ createAlignmentValue(boolean forceSplit, int wrapStyle, int indentStyle)5617 public static String createAlignmentValue(boolean forceSplit, int wrapStyle, int indentStyle) { 5618 int alignmentValue = 0; 5619 switch(wrapStyle) { 5620 case WRAP_COMPACT : 5621 alignmentValue |= Alignment.M_COMPACT_SPLIT; 5622 break; 5623 case WRAP_COMPACT_FIRST_BREAK : 5624 alignmentValue |= Alignment.M_COMPACT_FIRST_BREAK_SPLIT; 5625 break; 5626 case WRAP_NEXT_PER_LINE : 5627 alignmentValue |= Alignment.M_NEXT_PER_LINE_SPLIT; 5628 break; 5629 case WRAP_NEXT_SHIFTED : 5630 alignmentValue |= Alignment.M_NEXT_SHIFTED_SPLIT; 5631 break; 5632 case WRAP_ONE_PER_LINE : 5633 alignmentValue |= Alignment.M_ONE_PER_LINE_SPLIT; 5634 break; 5635 } 5636 if (forceSplit) { 5637 alignmentValue |= Alignment.M_FORCE; 5638 } 5639 switch(indentStyle) { 5640 case INDENT_BY_ONE : 5641 alignmentValue |= Alignment.M_INDENT_BY_ONE; 5642 break; 5643 case INDENT_ON_COLUMN : 5644 alignmentValue |= Alignment.M_INDENT_ON_COLUMN; 5645 } 5646 return String.valueOf(alignmentValue); 5647 } 5648 5649 /** 5650 * Returns the formatter settings that most closely approximate 5651 * the default formatter settings of Eclipse version 2.1. 5652 * 5653 * @return the Eclipse 2.1 settings 5654 * @since 3.0 5655 */ getEclipse21Settings()5656 public static Map getEclipse21Settings() { 5657 DefaultCodeFormatterOptions options = DefaultCodeFormatterOptions.getDefaultSettings(); 5658 options.page_width = 80; // changed with bug 356841 5659 options.comment_count_line_length_from_starting_position = false; 5660 return options.getMap(); 5661 } 5662 5663 /** 5664 * Returns the default Eclipse formatter settings 5665 * 5666 * @return the Eclipse default settings 5667 * @since 3.1 5668 */ getEclipseDefaultSettings()5669 public static Map getEclipseDefaultSettings() { 5670 return DefaultCodeFormatterOptions.getEclipseDefaultSettings().getMap(); 5671 } 5672 5673 /** 5674 * <p>Return the force value of the given alignment value. 5675 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 5676 * API. 5677 * </p> 5678 * 5679 * @param value the given alignment value 5680 * @return the force value of the given alignment value 5681 * @see #createAlignmentValue(boolean, int, int) 5682 * @exception IllegalArgumentException if the given alignment value is null, or if it 5683 * doesn't have a valid format. 5684 */ getForceWrapping(String value)5685 public static boolean getForceWrapping(String value) { 5686 try { 5687 int existingValue = Integer.parseInt(value); 5688 return (existingValue & Alignment.M_FORCE) != 0; 5689 } catch (NumberFormatException e) { 5690 throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$ 5691 } 5692 } 5693 5694 /** 5695 * <p>Return the indentation style of the given alignment value. 5696 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 5697 * API. 5698 * </p> 5699 * 5700 * @param value the given alignment value 5701 * @return the indentation style of the given alignment value 5702 * @see #createAlignmentValue(boolean, int, int) 5703 * @exception IllegalArgumentException if the given alignment value is null, or if it 5704 * doesn't have a valid format. 5705 */ getIndentStyle(String value)5706 public static int getIndentStyle(String value) { 5707 try { 5708 int existingValue = Integer.parseInt(value); 5709 if ((existingValue & Alignment.M_INDENT_BY_ONE) != 0) { 5710 return INDENT_BY_ONE; 5711 } else if ((existingValue & Alignment.M_INDENT_ON_COLUMN) != 0) { 5712 return INDENT_ON_COLUMN; 5713 } else { 5714 return INDENT_DEFAULT; 5715 } 5716 } catch (NumberFormatException e) { 5717 throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$ 5718 } 5719 } 5720 5721 /** 5722 * Returns the settings according to the Java conventions. 5723 * 5724 * @return the settings according to the Java conventions 5725 * @since 3.0 5726 */ getJavaConventionsSettings()5727 public static Map getJavaConventionsSettings() { 5728 return DefaultCodeFormatterOptions.getJavaConventionsSettings().getMap(); 5729 } 5730 /** 5731 * <p>Return the wrapping style of the given alignment value. 5732 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 5733 * API. 5734 * </p> 5735 * 5736 * @param value the given alignment value 5737 * @return the wrapping style of the given alignment value 5738 * @see #createAlignmentValue(boolean, int, int) 5739 * @exception IllegalArgumentException if the given alignment value is null, or if it 5740 * doesn't have a valid format. 5741 */ getWrappingStyle(String value)5742 public static int getWrappingStyle(String value) { 5743 try { 5744 int existingValue = Integer.parseInt(value) & Alignment.SPLIT_MASK; 5745 switch(existingValue) { 5746 case Alignment.M_COMPACT_SPLIT : 5747 return WRAP_COMPACT; 5748 case Alignment.M_COMPACT_FIRST_BREAK_SPLIT : 5749 return WRAP_COMPACT_FIRST_BREAK; 5750 case Alignment.M_NEXT_PER_LINE_SPLIT : 5751 return WRAP_NEXT_PER_LINE; 5752 case Alignment.M_NEXT_SHIFTED_SPLIT : 5753 return WRAP_NEXT_SHIFTED; 5754 case Alignment.M_ONE_PER_LINE_SPLIT : 5755 return WRAP_ONE_PER_LINE; 5756 default: 5757 return WRAP_NO_SPLIT; 5758 } 5759 } catch (NumberFormatException e) { 5760 throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$ 5761 } 5762 } 5763 /** 5764 * <p>Set the force value of the given alignment value and return the new value. 5765 * The given alignment value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 5766 * API. 5767 * </p> 5768 * 5769 * @param value the given alignment value 5770 * @param force the given force value 5771 * @return the new alignment value 5772 * @see #createAlignmentValue(boolean, int, int) 5773 * @exception IllegalArgumentException if the given alignment value is null, or if it 5774 * doesn't have a valid format. 5775 */ setForceWrapping(String value, boolean force)5776 public static String setForceWrapping(String value, boolean force) { 5777 try { 5778 int existingValue = Integer.parseInt(value); 5779 // clear existing force bit 5780 existingValue &= ~Alignment.M_FORCE; 5781 if (force) { 5782 existingValue |= Alignment.M_FORCE; 5783 } 5784 return String.valueOf(existingValue); 5785 } catch (NumberFormatException e) { 5786 throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$ 5787 } 5788 } 5789 5790 /** 5791 * <p>Set the indentation style of the given alignment value and return the new value. 5792 * The given value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 5793 * API. 5794 * </p> 5795 * 5796 * @param value the given alignment value 5797 * @param indentStyle the given indentation style 5798 * @return the new alignment value 5799 * @see #INDENT_BY_ONE 5800 * @see #INDENT_DEFAULT 5801 * @see #INDENT_ON_COLUMN 5802 * @see #createAlignmentValue(boolean, int, int) 5803 * @exception IllegalArgumentException if the given alignment value is null, if the given 5804 * indentation style is not one of the possible indentation styles, or if the given 5805 * alignment value doesn't have a valid format. 5806 */ setIndentStyle(String value, int indentStyle)5807 public static String setIndentStyle(String value, int indentStyle) { 5808 switch(indentStyle) { 5809 case INDENT_BY_ONE : 5810 case INDENT_DEFAULT : 5811 case INDENT_ON_COLUMN : 5812 break; 5813 default : 5814 throw new IllegalArgumentException("Unrecognized indent style: " + indentStyle); //$NON-NLS-1$; 5815 } 5816 try { 5817 int existingValue = Integer.parseInt(value); 5818 // clear existing indent bits 5819 existingValue &= ~(Alignment.M_INDENT_BY_ONE | Alignment.M_INDENT_ON_COLUMN); 5820 switch(indentStyle) { 5821 case INDENT_BY_ONE : 5822 existingValue |= Alignment.M_INDENT_BY_ONE; 5823 break; 5824 case INDENT_ON_COLUMN : 5825 existingValue |= Alignment.M_INDENT_ON_COLUMN; 5826 } 5827 return String.valueOf(existingValue); 5828 } catch (NumberFormatException e) { 5829 throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$ 5830 } 5831 } 5832 /** 5833 * <p>Set the wrapping style of the given alignment value and return the new value. 5834 * The given value should be created using the <code>createAlignmentValue(boolean, int, int)</code> 5835 * API. 5836 * </p> 5837 * 5838 * @param value the given alignment value 5839 * @param wrappingStyle the given wrapping style 5840 * @return the new alignment value 5841 * @see #WRAP_COMPACT 5842 * @see #WRAP_COMPACT_FIRST_BREAK 5843 * @see #WRAP_NEXT_PER_LINE 5844 * @see #WRAP_NEXT_SHIFTED 5845 * @see #WRAP_NO_SPLIT 5846 * @see #WRAP_ONE_PER_LINE 5847 * @see #createAlignmentValue(boolean, int, int) 5848 * @exception IllegalArgumentException if the given alignment value is null, if the given 5849 * wrapping style is not one of the possible wrapping styles, or if the given 5850 * alignment value doesn't have a valid format. 5851 */ setWrappingStyle(String value, int wrappingStyle)5852 public static String setWrappingStyle(String value, int wrappingStyle) { 5853 switch(wrappingStyle) { 5854 case WRAP_COMPACT : 5855 case WRAP_COMPACT_FIRST_BREAK : 5856 case WRAP_NEXT_PER_LINE : 5857 case WRAP_NEXT_SHIFTED : 5858 case WRAP_NO_SPLIT : 5859 case WRAP_ONE_PER_LINE : 5860 break; 5861 default: 5862 throw new IllegalArgumentException("Unrecognized wrapping style: " + value); //$NON-NLS-1$ 5863 } 5864 try { 5865 int existingValue = Integer.parseInt(value); 5866 // clear existing split bits 5867 existingValue &= ~(Alignment.SPLIT_MASK); 5868 switch(wrappingStyle) { 5869 case WRAP_COMPACT : 5870 existingValue |= Alignment.M_COMPACT_SPLIT; 5871 break; 5872 case WRAP_COMPACT_FIRST_BREAK : 5873 existingValue |= Alignment.M_COMPACT_FIRST_BREAK_SPLIT; 5874 break; 5875 case WRAP_NEXT_PER_LINE : 5876 existingValue |= Alignment.M_NEXT_PER_LINE_SPLIT; 5877 break; 5878 case WRAP_NEXT_SHIFTED : 5879 existingValue |= Alignment.M_NEXT_SHIFTED_SPLIT; 5880 break; 5881 case WRAP_ONE_PER_LINE : 5882 existingValue |= Alignment.M_ONE_PER_LINE_SPLIT; 5883 break; 5884 } 5885 return String.valueOf(existingValue); 5886 } catch (NumberFormatException e) { 5887 throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$ 5888 } 5889 } 5890 } 5891