[Skip to content]
TRIEMAX Software
You are here: Home > Products > Jalopy >

### 2.6.3. Wrapping

Controls when and how lines are wrapped.

#### 2.6.3.1. General

Lets you control the general line wrapping options.

Figure 2.36. Wrapping settings page

##### 2.6.3.1.1. General

Lets you control the general line wrapping options.

###### Wrap lines

Enables or disables automatic line wrapping. When enabled, Jalopy tries to keep lines within the maximal line length and breaks statements across lines when necessary.

Please note that disabling line wrapping does not mean that existing line breaks will be kept, but rather that no efforts are taken to keep lines in between the maximal line length upon reformatting!

###### Line length

Lets you specify the maximal line length. Jalopy tries (more or less - depending on the used indentation scheme) to limit each line within the given length.

##### 2.6.3.1.2. Policy

Lets you define the wrapping policy for operators.

Line wrapping will often occur with statements that consist of several (possibly long) expressions. Here you specify whether line wrapping should occur before or after the expression operator.

###### Wrap before operators

If enabled, line breaks will be inserted before operators.

Example 2.424. Wrap before operators (Standard indented)

    if ((condition1 && condition2)
        || (condition3 && condition4)
        || !(condition5 && condition6)) {
        doSomethingAboutIt();
    }

###### Wrap after operators

If enabled, line breaks will be inserted after operators.

Example 2.425. Wrap after operators (Standard indented)

    if ((condition1 && condition2) ||
        (condition3 && condition4) ||
        !(condition5 && condition6)) {
        doSomethingAboutIt();
    }

Please note that wrapping for the comma and dot operator is currently always performed after the operators!

If you happen to use Sun Brace styling, you might want to enable continuation indentation for blocks to let the statement body stand out. See "Block continuation indentation" for more information.

##### 2.6.3.1.3. Keep line breaks

Lets you specify around which code elements line breaks should be kept.

###### Declaration parameters

When enabled, existing line breaks after the commas of declaration parameters are kept. Otherwise line wrapping is performed according to the current settings.

Since 1.6

Example 2.426. Nicely laid out method declaration

    void test( String rName,
               boolean rPendandic ) {
        ...
    }

After formatting this code could look like this (because everything fits in one line):

Example 2.427. Method call after formatting

    void test( String rName, boolean rPendandic ) {
        ...
    }

But with the "Keep line breaks" option enabled, it may look like this:

Example 2.428. Method declaration after formatting with kept line breaks (Endline indented)

    void test( String rName,
               boolean rPendandic ) {
        ...
    }

###### Call arguments

When enabled, existing line breaks after the commas of call arguments are kept. Otherwise line wrapping is performed according to the current settings.

Since 1.6

Example 2.429. Nicely laid out method call

    obj.method1( test,
                 test2,
                 test3 );

After formatting this code could look like this (because everything fits in one line):

Example 2.430. Method call after formatting

    obj.method1( test, test2, test3 );

But with the "Keep line breaks" option enabled, it may look like this:

Example 2.431. Method call after formatting with kept line breaks (Endline indented)

    obj.method1( test,
                 test2,
                 test3 );

###### Operators

When enabled, existing line breaks before or after infix operators and the comma operator of method declaration parameters or method call arguments are kept. Otherwise line wrapping is performed according to the current settings.

Since 1.0

Example 2.432. Operators with forced line breaks

    if ((condition1 && condition2)
        || (condition3 && condition4)
        || !(condition5 && condition6))
    {
        ...
    }

After formatting this code could look like this (because not everything fits in one line and not line breaks are forced):

Example 2.433. Operators after formatting (wrapping is done on-demand)

    if ((condition1 && condition2) || (condition3 && condition4) ||
        !(condition5 && condition6))
    {
        ...
    }

But with the "Keep line breaks" option enabled, it may look like this:

Example 2.434. Operators after formatting with kept line breaks

    if ((condition1 && condition2) ||
        (condition3 && condition4) ||
        !(condition5 && condition6))
    {
        ...
    }

Please note that it does not matter what wrapping policy for operators you choose. Jalopy will keep line breaks even if the operators move!

###### String concats

When enabled, existing line breaks before or after the plus operator of concatenated string literals are kept. Otherwise line wrapping is performed according to the current settings.

Since 1.0.1

Example 2.435. Nicely laid out string constant

    query = "select a.prop_text, "
            + "       a.contest_title, "
            + "  from contest a "
            + "  where a.language_code = b.language_code "
            + "    and b.bob = c.bob "
            + "    and a.x = ? "
            + "  order by a.bob, "
            + "           c.language";

After formatting this code could look like this:

Example 2.436. String constant after formatting

    query = "select a.prop_text, " + "       a.contest_title, " +
        "  from contest a "  + "  where a.language_code = b.language_code " +
        "    and b.bob = c.bob " + "    and a.x = ? " + "  order by a.bob, " +
        "           c.language";

But with the "Keep string concats" option enabled, it may look like this:

Example 2.437. String constant after formatting with "Keep line breaks" (Standard indented)

    query = "select a.prop_text, " +
        "       a.contest_title, " +
        "  from contest a " +
        "  where a.language_code = b.language_code " +
        "    and b.bob = c.bob " +
        "    and a.x = ? " +
        "  order by a.bob, " +
        "           c.language";

Please note that it does not matter what wrapping policy for operators you choose. Jalopy will keep line breaks even if the operators move!

###### Array elements

When enabled, existing line breaks after the separator comma of array elements are kept. Otherwise line wrapping is performed according to the current settings.

Since 1.5

Example 2.438. Array declarations

    String[] foo = new String[]
        {
            "foo",
        };

    String[] bar = new String[]
        {
            "bar",
            "car",
        };

Example 2.439. Array declarations after reformat

    String[] foo = new String[] { "foo", };

    String[] bar = new String[] { "bar", "car", };

Example 2.440. Array declarations after reformat with "Keep line breaks"

    String[] foo = new String[]
        {
            "foo",
        };

    String[] bar = new String[]
        {
            "bar",
            "car",
        };

###### Strictly obey "Keep line breaks"

When using endline indentation, line breaks may not always be kept because doing so would break the endline indent contract and lead to inconsistent indentation behavior. Enabling this option will cause Jalopy to keep existing line breaks even in such cases.

Please note that this option is only available when endline indentation is enabled and any of the "Keep line breaks" options selected!

Since 1.8

Take the following example:

Example 2.441. Method call

    String firstSymbol = eraseNonBreakingSpaceFromSymbol(
        symbol1, symbol2);

When the option is disabled, Jalopy won't keep the line break before the first call argument because it goes against the endline indentation rules.

Example 2.442. Method call - endline indented

    String firstSymbol = eraseNonBreakingSpaceFromSymbol(symbol1,
                                                         symbol2);

But if you really favor keeping the line break, enabling the option would yield:

Example 2.443. Method call - line break kept

    String firstSymbol = eraseNonBreakingSpaceFromSymbol(
            symbol1, symbol2);

###### Treat two string literals as string concatenation

This option lets you control what is considered a string concatenation. By default, Jalopy treats the plus (+) operator as a string concatenation when either one of the operands is a string literal. But you might want to narrow this behavior to only treat two string literals as a string concatenation.

Please note that this option is only available when any of the "Keep line breaks" options is selected!

Since 1.8

When this option is disabled, all operators in the example below would be considered string concatenations and therefore line breaks kept.

Example 2.444. String concatenations

    String query = "select a.prop_text, "
                   + "       a.contest_title, "
                   + "  from contest a "
                   + "  where a.language_code = b.language_code ";

    String name = "Walther"
                  + getNick();

When enabled, only those plus operators with two string literals on either side would retain any line breaks like in the example below.

Example 2.445. String concatenations

    String query = "select a.prop_text, "
                   + "       a.contest_title, "
                   + "  from contest a "
                   + "  where a.language_code = b.language_code ";

    String name = "Walther" + getNick();

##### 2.6.3.1.4. Miscellaneous

###### Disable wrapping for complex expressions

For complex expressions a common technique to enhance readability is to break the expression into several subexpressions that can be stored in temporary variables that are placed on different lines.

Example 2.446. Complex expression

    if (conditionOne &&                                |
        ("foo".equals(aStr) || "bar".equals(aStr))     |
      doSomething();                                   |

Example 2.447. Refactored expression

    boolean conditionTwo = "foo".equals(aStr);         |
    boolean conditionThree = "bar".equals(aStr);       |
                                                       |
    if (conditionOne &&                                |
        (conditionTwo || conditionThree))              |
      doSomething();                                   |

In order to determine occurences of complex expressions, enabling this option will cause automatic line wrapping to be disabled when a complex expression gets printed. A warning message will be logged in the Printer category that informs you about the location of the expression.

Since 1.5

Example 2.448. Flagged complex expression

                                                       |
    if (conditionOne && (conditionTwo || conditionThree))
      doSomething();                                   |

###### Avoid bare left parenthesis

With Endline indentation and "Wrap on-demand after left parenthesis" or "Keep line break for operators" enabled, line breaks after left parentheses may look ugly. If this option is enabled, such line breaks are avoided.

This option was mainly introduced to fix some unwanted behavior of earlier releases without breaking compatiblity. It is recommended to have it enabled.

Since 1.4

Example 2.449. Bare left parenthesis

    this.customerNumber = new CustomerNumber(
                                             ServiceManager.createService());

Example 2.450. Avoided bare left parenthesis

    this.customerNumber = new CustomerNumber(ServiceManager.createService());

#### 2.6.3.2. Arrays

Contains options to control the general wrapping behavior for arrays.

##### Wrap as needed

Enabling this options means array elements will be wrapped so that they will be limited within the current maximal line length.

Example 2.451. Wrap as needed

    String[] s = new String[] {              |
        "first", "second", "third", "fourth",|
        "fifth", "sixth", "seventh",         |
        "eighth", "ninth", "tenth",          |
    };                                       |

##### Wrap all when exceed

Forces a line break after every array element when all elements would not fit into the current line limit.

Since 1.7

Example 2.452. All elements fit into line

    String[] s = new String[] {                                           |
        "first", "second", "third", "fourth", "fifth", "sixth", "seventh",|
    };                                                                    |

Example 2.453. Wrap all elements when line would get exceeded

    String[] s = new String[] {                                           |
        "first",                                                          |
        "second",                                                         |
        "third",                                                          |
        "fourth",                                                         |
        "fifth",                                                          |
        "sixth",                                                          |
        "seventh",                                                        |
        "eighth",                                                         |
    };                                                                    |

##### Wrap after element

Forces a new line after every n-th element.

Example 2.454. Wrap after element 1

    String[] s = new String[] {    |
        "first",                   |
        "second",                  |
        "third",                   |
        "fourth",                  |
        "fifth",                   |
        "sixth",                   |
        "seventh",                 |
        "eighth",                  |
        "ninth",                   |
        "tenth",                   |
    };

Please note that no checking is done regarding the maximal line length limit which might easily lead to lines exceeding the maximal line length when you set n to something bigger than '1'.

Example 2.455. Wrap after element 3

    String[] s = new String[] {    |
        "first", "second", "third",|
        "fourth", "fifth", "sixth",|
        "seventh", "eighth", "ninth",
        "tenth",                   |
    }                              |

If neither option is enabled, the array elements will be printed in one line, right after the left curly brace, i.e. automatic line wrapping will be disabled.

Please note that you can further customize the wrapping behavior for arrays with the following options:

- "Compact array initializer"
- "Keep line breaks for arrays"

#### 2.6.3.3. Always

Lets you choose the elements that should be wrapped always.

Figure 2.37. Wrapping Always settings page

##### 2.6.3.3.1. Wrap always

For certain cases, the need may arise to force line wrapping to achieve a consistent, uniform look. If you enable any of the following switches, line wrapping will occur for the specified cases no matter whether you have enabled general line wrapping or not.

###### Before declaration keywords

Forces a line break before the `class`, `interface` keyword, `enum` and `@interface` keywords.

Since 1.4

Example 2.456. Class declaration

    public class FooBar {
        ...
    }

Example 2.457. Wrapped class declaration

    public
    class FooBar {
        ...
    }

###### After "class" keyword

Forces a line break after the `class` keyword.

Since 1.3

Example 2.458. Class declaration

    public class FooBar {
        ...
    }

Example 2.459. Wrapped class declaration

    public class
    FooBar {
        ...
    }

###### Before extends keyword

Forces a line break before the extends keyword of a class/interface declaration.

Example 2.460. Class/interface extends keyword

    public interface Channel extends Puttable, Takable {
        ...
    }

Example 2.461. Wrapped class/interface extends keyword (Standard indented)

    public interface Channel
        extends Puttable, Takable {
        ...
    }

You can control the space printed before the keyword via the indentation settings. See "Extends indent size" for more information.

###### After extends types

Forces a line wrap after each type name of the extended classes.

Example 2.462. Class/interface extends types

    public interface Channel extends Puttable, Takable {
        ...
    }

Example 2.463. Wrapped class/interface extends types (Endline indented)

    public interface Channel extends Puttable,
                                     Takable {
        ...
    }

###### Before implements keyword

Forces a line break before the implements keyword of a class declaration.

Example 2.464. implements keyword

    public class SynchronizedBoolean implements Comparable, Cloneable {
        ...
    }

Example 2.465. Wrapped implements keyword (Standard indented)

    public class SynchronizedBoolean
        implements Comparable, Cloneable {
        ...
    }

You can control the space printed before the keyword via the indentation settings. See "Implements indent size" for more information.

###### After implements types

Forces a line wrap after each type name of the implemented classes.

Example 2.466. Class implements types

    public class SynchronizedBoolean implements Comparable, Cloneable {
        ...
    }

Example 2.467. Wrapped class implements types (Endline indented)

    public class SynchronizedBoolean implements Comparable,
                                                Cloneable {
        ...
    }

###### Before throws keyword

Forces a line break before the throws keyword of a method/constructor declaration.

Example 2.468. throws keyword

    private File getDestinationFile(File dest, String packageName,
                                    String filename) throws IOException {
        ...
    }

Example 2.469. Wrapped throws keyword (Endline indented)

    private File getDestinationFile(File dest, String packageName,
                                    String filename)
                             throws IOException {
        ...
    }

You can control the space printed before the keyword via the indentation settings. See "Throws indent size" for more information.

###### After throws keyword

Forces a line break after the `throws` keyword.

Since 1.3

Example 2.470. Throws signature

    public void foo()
        throws FooException,
            BarException {
        ...
    }

Example 2.471. Throws signature (wrapped)

    public void foo()
        throws
            FooException,
            BarException {
        ...
    }

###### After throws types

Forces a line wrap after each type name of the throws clause of a method/constructor declaration.

Example 2.472. throws types

    private File getDestinationFile(File dest, String packageName,
                                    String filename)
                             throws IOException, FooException {
        ...
    }

Example 2.473. Wrapped throws types (Standard indented)

    private static final File getDestinationFile(File dest, String packageName,
                                                 String filename)
        throws IOException,
            FooException {
        ...
    }

Example 2.474. Wrapped throws types (Endline indented)

    private File getDestinationFile(File dest, String packageName,
                                    String filename)
                             throws IOException,
                                    FooException {
        ...
    }

###### Enum constants

When ennabled, forces a line break after each enum constant of an enum declaration.

Since 1.2

Example 2.475. Enum constants

    public enum Season {
        WINTER, SPRING, SUMMER, FALL
    }

Example 2.476. Forced line break after enum constants

    public enum Season {
        WINTER,
        SPRING,
        SUMMER,
        FALL
    }

###### Marker annotations

When enabled, a line break will be inserted after the last marker annotation, when no other Java modifiers appear before the annotation.

Since 1.1

Example 2.477. No line break after marker annotation

    @Preliminary public class TimeTravel {
        ...
    }

Example 2.478. Line break after marker annotation

    @Preliminary
    public class TimeTravel {
        ...
    }

Example 2.479. No line break after marker annotation when modifier(s) before

    public @Preliminary class TimeTravel {
        ...
    }

You can ensure that marker annotations appear before other Java modifiers via the modifiers sorting settings, see Section 2.6.6.2.2, "Sort Order" for more information.

###### Annotation members

When enabled, a line break will be inserted after each member of a normal annotation. Additionally, line breaks will occur after the left and before the right parenthesis.

Otherwise, a line break after a member value pair only happens when the maximal line would be exceeded. Line breaks after left and before right parenthesis are only printed when all members does not fit into one line.

Since 1.5

Example 2.480. Line breaks after annotation members

    @Author(
        @Name(
            first = "Joe",
            last = "Hacker"
        )
    )
    public class BitTwiddle { ... }

Example 2.481. No line break after members

    @Author(@Name(first = "Joe", last = "Hacker"))
    public class BitTwiddle { ... }

Example 2.482. No line break after members

    @Author(                                                        |
        @Name(first = "Joe", last = "Hacker", location = "Redmond") |
    )                                                               |
    public class BitTwiddle { ... }                                 |

###### Field declaration names

Forces a line wrap before the name of an instance field declaration. Please note that this option does not apply for multi-variables.

Since 1.2

Example 2.483. Field declaration

    private int _count = 0

Example 2.484. Field declaration with line break between before the name

    private int
    _count = 0

###### Method declaration names

Forces a line wrap before the name of a method or constructor declaration.

Since 1.0.3

Example 2.485. Method declaration

    public static int foo()
    {
        ...
    }

Example 2.486. Method declaration with line break between return type and name

    public static int
    foo()
    {
        ...
    }

###### Declaration parameters

Forces a line break after each parameter of a method or constructor declaration.

Example 2.487. Method declaration parameters

    public static File create(File file, File directory, int backupLevel)
                       throws IOException {
        ...
    }

Example 2.488. Wrapped method declaration parameters (Endline indented)

    public static File create(File file,
                              File directory,
                              int backupLevel)
                       throws IOException {
        ...
    }

###### Call arguments

Forces a line wrap after each argument of a method call.

Example 2.489. Method call

    doSomething();
    _userDatabase.addUser("Name", encryptPassword("password", _secretKey),
                          "123 fake address");
    doSomethingElse();

Example 2.490. Wrapped method call (Endline indented)

    doSomething();
    _userDatabase.addUser("Name",
                          encryptPassword("password",
                                          _secretKey),
                          "123 fake address");
    doSomethingElse();

###### Nested call arguments

Forces a line wrap after each argument of a method call if at least one argument is a method call itself. This option can prove especially useful if one prefers to nest method calls as arguments rather than adding local variables just to hold those arguments.

Example 2.491. Wrapped nested method call (Endline indented)

    doSomething();
    _userDatabase.addUser("Name",
                          encryptPassword("password", _secretKey),
                          "123 fake address");
    doSomethingElse();

###### Chained method calls

Forces a line wrap after each chained method call.

Example 2.492. Chained method call

    message.format(ERROR_SOURCE_ADDRESS).param (m_session.getAimName()).send();

Example 2.493. Wrapped chained method call (aligned)

    message.format(ERROR_SOURCE_ADDRESS)
           .param (m_session.getAimName())
           .send();

Please note that you can control the aligment for chained method calls with the "Align chained method call" option.

###### Nested chained method calls

Forces a line wrap after each method call chain of nested method calls, i.e. method calls used as call arguments.

Example 2.494. Chained method call

    message.format(ERROR_SOURCE_ADDRESS).param (m_session.getAimName()).send();

Example 2.495. Wrapped chained method call (aligned)

    message.format(ERROR_SOURCE_ADDRESS)
           .param (m_session.getAimName())
           .send();

Please note that you can control the aligment for chained method calls with the "Align chained method call" option.

Since 1.6

###### Multi variable types

When enabled, a line break will be printed after the type identifier of the declaration.

Since 1.0

Example 2.496. Standard multi-variable

    BigInteger q = null, p = null, g = null;

Example 2.497. Force wrap after type of multi-variables (Standard indented)

    BigInteger
        q = null, p = null, g = null;

###### Multi variable declarators

When enabled, each declaration of a multi-variable declaration gets always printed on a new line. Otherwise, wrapping only occurs when necessary.

Since 1.0

Example 2.498. Standard multi-variable

    BigInteger q = null, p = null, g = null;

Example 2.499. Force wrap after each declarator of multi-variables (Endline indented)

    BigInteger q = null,
               p = null,
               g = null;

###### Ternary expression question mark (`?`)

Forces a line wrap after the first operand.

Example 2.500. Wrapped ternary expression question mark (Endline indented)

    String comma = spaceAfterComma
                   ? COMMA_SPACE : COMMA;

Indentation for consecutive lines depends on the used indentation scheme. See Section 2.6.4.1.1, "Strategies" for more information. You may further want to use continuation indentation.

###### Ternary expression colon (`:`)

Forces a line wrap after the second operand.

Example 2.501. Wrapped ternary expression colon (Endline indented)

    String comma = spaceAfterComma ? COMMA_SPACE
                                   : COMMA;

If both switches are disabled, ternary expressions are printed in one line (if everything fits in one line, that is).

Example 2.502. Ternary expressions

    String comma = spaceAfterComma ? COMMA_SPACE : COMMA;

If both switches are enabled, you can force a style like the following:

Example 2.503. Wrapped ternary expressions (Standard indented)

    String comma = spaceAfterComma
        ? COMMA_SPACE
        : COMMA;

###### Labels

Forces a line wrap after labels.

Example 2.504. Label

    // advance to the first CLASS_DEF or INTERFACE_DEF
    LOOP:   for (AST child = tree.getFirstChild();
                 child != null;
                 child = child.getNextSibling()) {
                switch (child.getType()) {
                    case JavaTokenTypes.CLASS_DEF :
                    case JavaTokenTypes.INTERFACE_DEF :
                        next = child;
                        break LOOP;

                    default :
                        break;
                }
            }

Example 2.505. Wrapped label (Standard indented)

    // advance to the first CLASS_DEF or INTERFACE_DEF
    LOOP:
            for (AST child = tree.getFirstChild();
                 child != null;
                 child = child.getNextSibling()) {
                switch (child.getType()) {
                    case JavaTokenTypes.CLASS_DEF :
                    case JavaTokenTypes.INTERFACE_DEF :
                        next = child;
                        break LOOP;

                    default :
                        break;
                }
            }

###### Registry Keys

Forces line wrapping after assignments for constants whose names ends with the "Registry" suffix.

Since 1.7

Example 2.506. Registry keys

    class FooRegistry {
        boolean ALLOW_FAKE_FOOS = Registry.contains(KEY_FAKE_FOOS);
    }

Example 2.507. Registry keys (wrapping forced)

    class FooRegistry {
        boolean ALLOW_FAKE_FOOS =
            Registry.contains(KEY_FAKE_FOOS);
    }

#### 2.6.3.4. On-demand

Lets you choose the elements that should be wrapped only when necessary. Either when the maximal line length would be exceeded otherwise or when related elements were already wrapped.

Figure 2.38. Wrapping On-demand settings page

##### 2.6.3.4.1. Wrap when exceed

Lets you enable and/or control wrapping for certain elements when the maximal line length would be exceeded without wrapping.

###### Import declarations

Enabling this option causes import declarations to be wrapped along the dots if otherwise the maximal line length would be exceeded. If left disabled, no line wrapping will ever occur for import declarations.

Since 1.4

Example 2.508. Very long import declaration

                                                            |
    import com.mycompanyname.myprojectname.mypackagename.MyClassName;
                                                            |

Example 2.509. Wrapped import declaration

                                                            |
    import com.mycompanyname.myprojectname.mypackagename    |
        .MyClassName;                                       |

###### Before extends keyword

When enabled, a line break is printed before the extends keyword of extends clauses when the whole clause does not fit into the current line.

Since 1.7

Example 2.510. extends clause

                                                            |
    interface Testable extends Transferable, Recordable, Playable {
    }                                                       |

Example 2.511. Wrapped throws clause

    interface Testable                                      |
        extends Transferable, Recordable, Playable {        |
    }                                                       |

###### Before implements keyword

When enabled, a line break is printed before the implements keyword of implements clauses when the whole clause does not fit into the current line.

Since 1.7

Example 2.512. implements clause

                                                            |
    class Testable implements Transferable, Recordable, Playable {
    }
                                                            |

Example 2.513. Wrapped implements clause

    class Testable                                          |
        implements Transferable, Recordable, Playable {     |
    }                                                       |

###### Before throws keyword

When enabled, a line break is printed before the keyword keyword of throws clauses when the whole clause does not fit into the current line.

Since 1.7

Example 2.514. throws clause

                                                            |
    public void performaAction() throws InvalidStateException {
    }
                                                            |

Example 2.515. Wrapped throws clause

    public void performaAction()                            |
        throws InvalidStateException {                      |
    }                                                       |

###### Marker annotations

When enabled, a line break will be inserted after the last marker annotation, when no other Java modifiers appear before the annotation and the declaration the annotation is part of, does not fit into the current line length limit.

Since 1.7

Example 2.516. No line break after marker annotation

                                                           |
    @Preliminary interface Testable extends Transferable,  |
        Recordable {                                       |
        ...                                                |
    }                                                      |

Example 2.517. Line break after marker annotation

    @Preliminary                                           |
    interface Testable extends Transferable, Recordable {  |
        ...                                                |
    }                                                      |

Please note that wrapping after the marker annotation only occurs, if other modifiers appear before the annotation!

Example 2.518. No line break after marker annotation when modifier(s) before

    public @Preliminary class TimeTravel {
        ...
    }

You can ensure that marker annotations appear before other Java modifiers via the modifiers sorting settings, see Section 2.6.6.2.2, "Sort Order" for more information.

Related options:

- "Wrap always after marker annotations"

###### Field declaration names

Issues a line break before the name of a field declaration when the maximal line length would be exceeded otherwise.

Since 1.7

Example 2.519. Field declaration which exceeds line length

    public static final InputMethodHighlight UNSELECTED_TEXT_HIGHLIGHTS =
        new InputMethodHighlight(false, CONVERTED_TEXT);          |

Example 2.520. Wrapped method declaration

    public static final InputMethodHighlight                      |
         UNSELECTED_TEXT_HIGHLIGHTS =                             |
             new InputMethodHighlight(false, CONVERTED_TEXT);     |

###### Method declaration names

Issues a line break before the name of a method or constructor declaration when the maximal line length would be exceeded otherwise.

Since 1.3

Example 2.521. Method declaration which exceeds line length

    protected PropertyChangeListener createPropertyChangeListener() {
    }                                                             |

Example 2.522. Wrapped method declaration

    protected PropertyChangeListener                              |
    createPropertyChangeListener() {                              |
    }                                                             |

###### After assignments

Lets you control the way wrapping takes action for assignments. If left disabled, line wrapping preferably occurs as part of the expression printing. Otherwise wrapping will be performed right after the assignment whenever the expression cannot be printed in just one line.

Example 2.523. Prefer wrap along the expression

    this.interessentenNr = new InteressentenNr(
            Fachschluesselerzeugung.createService()
            .getNeuerFachschluessel(
                FachschluesselerzeugungService.FACHSCHLUESSEL_KZ_INTERESSENT
            )
        );

Example 2.524. Prefer wrap after assignment

    this.interessentenNr =
        new InteressentenNr(
            Fachschluesselerzeugung.createService()
            .getNeuerFachschluessel(
                FachschluesselerzeugungService.FACHSCHLUESSEL_KZ_INTERESSENT
            )
        );

###### After "return" statement

Lets you control the wrapping behavior for return statements. If enabled, a line break is inserted after the return statment when the expression would exceed the maximal line length.

Since 1.2.1

Example 2.525. return statement

    return ((getKey() == null) ? (other.getKey() == null)           |
                               : getKey().equals(other.getKey()));  |

Example 2.526. Prefer wrapping after return statement

    return                                                          |
        ((getKey() == null) ? (other.getKey() == null)              |
                            : getKey().equals(other.getKey()));     |

###### After left parenthesis

Lets you control the wrapping behavior for parameter, statement and expression lists.

If left disabled, the first line break will be preferably inserted behind the first parameter or expression and only occurs after the left parenthesis if the maximal line length would be otherwise exceeded.

Example 2.527. Wrap after left parenthesis (disabled)

    appServerReferencesVector.add(new AppServerReference(
            "RemoteApplicationManager",
            poa.create_reference_with_id(
                "RemoteApplicationManager".getBytes(),
                RemoteApplicationManagerHelper.id())));

When enabled, the line break will always occur behind the left parenthesis when the list parameters, arguments or expressions cannot be printed in just one line.

Example 2.528. Wrap after left parenthesis (enabled)

    appServerReferencesVector.add(
        new AppServerReference(
            "RemoteApplicationManager",
            poa.create_reference_with_id(
                "RemoteApplicationManager".getBytes(),
                RemoteApplicationManagerHelper.id())));

This option affects the output style of method/constructor declarations and calls, creator calls and `if-else`, `for`, `while` and `do-while` blocks.

As per default, the wrapped lines will be indented using standard indentation, but you may want to apply another indentation scheme. See Section 2.6.4.1.1, "Strategies" for more information.

###### Before right parenthesis

Prints a line break before the right parenthesis of parameter or expression lists when at least one parameter/expression was wrapped. The parenthesis will be intended according to the current indentation level.

This switch affects the output style of method/constructor declarations and calls, creator calls and `if-else`, `for`, `while` and `do-while` blocks.

Example 2.529. Right parenthesis (disabled)

    public void severalParameters(String one,
                                  int two,
                                  String three,
                                  StringObject four,
                                  AnotherObject five) {
    }

Example 2.530. Right parenthesis (enabled)

    public void severalParameters(String one,
                                  int two,
                                  String three,
                                  StringObject four,
                                  AnotherObject five
    ) {
    }

Both switches combined, looks like the following example:

Example 2.531. Left and right parenthesis

    appServerReferencesVector.add(
        new AppServerReference(
            "RemoteApplicationManager",
            poa.create_reference_with_id(
                "RemoteApplicationManager".getBytes(),
                RemoteApplicationManagerHelper.id()
            )
        )
    );

For blocks the output may go like this:

Example 2.532. Left and right parenthesis (wrapped)

    if (
        "pick".equals(m.getName()) && m.isStatic() && m.isPublic()
    ) {
        pickFound = true;
    } else if (
        "pick".equals(m.getName()) && m.isStatic() && m.isPublic()
    ) {
        pickFound = true;
    }

###### Grouping parentheses

Lets you control the wrapping behavior for grouping parentheses. If enabled, line breaks are inserted after left and before right parentheses of grouped expressions to let the expression(s) stand out.

Example 2.533. Grouping parentheses (standard indented)

    if (
        !((bankverbindung instanceof ObjectValue)
        || (bankverbindung instanceof PrimitiveValue))
    ) {
        throw new RuntimeException();
    }

Example 2.534. Wrapped grouping parentheses (standard indented)

    if (
        !(
            (bankverbindung instanceof ObjectValue)
            || (bankverbindung instanceof TkPrimitiveValue)
        )
    ) {
        throw new RuntimeException();
    }

###### Type parameter

When enabled, type parameters of parameterized (generic) types are wrapped, when necessary.

Since 1.4

Example 2.535. Parameterized type that lead to exceeded maximal line length

                                                                          |
    private final Map<Short, String> example = new HashMap<Short, String>();
                                                                          |

Example 2.536. Wrapped parameterized type (endline indented)

                                                                          |
    private final Map<Short, String> example = new HashMap<Short,         |
                                                           String>();     |
                                                                          |

Please note that with Endline indentation enabled, wrapping only happens if both type parameter names are either not single-lettered or contain one ore more bounds.

Example 2.537. Exceptions when using endline indentation

                                                         |
    public class Test<A, B extends Comparable<B> & Cloneable> {
    }                                                    |

###### Within call after assignment

This option lets you define where a line wrap should preferably occur for call statements after assignments that don't fit into the maximal line length.

This is option is only meant to let you adjust behavior when "Prefer wrap after assignments" has been enabled. Please see explanation there.

Since 1.7

Example 2.538. Wrapping assignment expression

    nuMBeans =
         NuvegaPropertiesHandler.getNNuvegaArrayProperty(
             NuvegaProperties.PROPERTIES_FILE_NUVEGA_BEAN_NAME);

Example 2.539. Prefer wrapping within call

    nuMBeans = NuvegaPropertiesHandler.getNNuvegaArrayProperty(
             NuvegaProperties.PROPERTIES_FILE_NUVEGA_BEAN_NAME);

###### Within call arguments

This option lets you define where a line wrap should preferably occur for call arguments that does not fit into the maximal line length.

Normally a line gets wrapped before a call argument that don't fit into the maximal line length. Enabling this option will cause a line break inserted within the call argument for operator expressions when the operator expression is not immediately preceded with or followed by another operator expression.

Since 1.5

Example 2.540. Wrapping method call (default behavior)

    failed(output, "a" + "b", null,                           |
            "Failed to open prefs: " + e.getMessage());       |
                                                              |

As you can see from the above example a line break is inserted before the third argument as it would exceed the maximal line length when printed in the same line.

Example 2.541. Prefer wrapping within call argument

    failed(output, "a" + "b", null, "Failed to open prefs: "  |
           + e.getMessage());                                 |
                                                              |

When the option is enabled, the line break happens within along the operator of the third argument.

Example 2.542. Standard wrapping when two operator expressions

    failed(output, "a" + "b",                                 |
           "Failed to open prefs: " + e.getMessage());        |
                                                              |

But if two operator expressions follow immediately, the standard behavior applies in order to enhance readibility.

##### 2.6.3.4.2. Wrap all when exceed

Lets you enable wrapping for all elements if the parameter or expression list or clause would otherwise exceed the maximal line length. If you enable any of the following switches, line wrapping may occur for the specified cases no matter whether you have enabled general line wrapping or not.

###### After "extends" types

Forces a line wrap after each type name of the `extends` clause of a class/interface declaration if the whole clause does not fit in one line.

Example 2.543. Extends types wrapped as needed (Standard indented)

    public interface VeryImportantInterface                        |
        extends LeastImportantInterface, LessImportantInterface,   |
            ImportantInterface {                                   |
        ...                                                        |
    }                                                              |

Example 2.544. Extends types wrapping forced (Standard indented)

    public interface VeryImportantInterface                        |
        extends LeastImportantInterface,                           |
            LessImportantInterface,                                |
            ImportantInterface {                                   |
        ...                                                        |
    }                                                              |

###### After "implements" types

Forces a line wrap after each type name of the `implements` clause of a class/interface declaration if the whole clause does not fit in one line.

Example 2.545. Implements types wrapped as needed (Standard indented)

    public class ImportantClass                                    |
        implements ImportantInterface, Serializable, Comparable,   |
            Cloneable {                                            |
        ...                                                        |
    }                                                              |

Example 2.546. Implements types wrapping forced (Standard indented)

    public class ImportantClass                                    |
        implements ImportantInterface,                             |
            Serializable,                                          |
            Comparable,                                            |
            Cloneable {                                            |
        ...                                                        |
    }                                                              |

###### After "throws" types

Forces a line wrap after each type name of the `throws` clause of a method/constructor declaration if the whole clause does not fit in one line.

Example 2.547. Throws types wrapped as needed (Endline indented)

    private File getDestinationFile(File dest, String packageName, |
                                    String filename)               |
                             throws IOException, FooException,     |
                                    FooBarException {              |
        ...                                                        |
    }                                                              |

Example 2.548. Throws types wrapping forced (Endline indented)

    private File getDestinationFile(File dest, String packageName, |
                                    String filename)               |
                             throws IOException,                   |
                                    FooException,                  |
                                    FooBarException {              |
        ...                                                        |
    }                                                              |

###### Declaration parameters

When enabled, forces a line break after all method declaration parameters when not all parameters fit into a single line.

Since 1.2

Example 2.549. Method declaration with multiple parameters execeeding line length

                                                                     |
    protected void processRequest( Request req, Response res, State state ) {
        ...                                                          |
    }                                                                |

Example 2.550. Method declaration with multiple parameters after wrapping

                                                                     |
    protected void processRequest( Request req,                      |
                                   Response res,                     |
                                   State state ) {                   |
        ...                                                          |
    }                                                                |

Related options:

- "Wrap all parameters when first wrapped"
- "Wrap after left parentheses when exceed"

###### Call arguments

When enabled, forces a line break after all method or creator call arguments when not all arguments fit into a single line.

Since 1.2

Example 2.551. Method call with multiple args execeeding line length

                                          |
    processRequest( request, response, state );
                                          |

Example 2.552. Method call with multiple args after wrapping

                                          |
    processRequest( request,              |
                    response,             |
                    state );              |

##### 2.6.3.4.3. Wrap all when first wrapped

###### After parameters/expressions

If enabled, this switch will cause all parameters/expressions to be wrapped, if and only if the first parameter/expression of the list has been wrapped.

Example 2.553. Expression list (all wrapped)

    if (
        "pick".equals(m.getName()) &&
        m.isStatic() &&
        m.isPublic()
    ) {
        pickFound = true;
    } else if (
        "pick".equals(m.getName()) &&
        m.isStatic() &&
        m.isPublic()
    ) {
        pickFound = true;
    }

Related options:

- "Wrap on-demand declaration parameters"

###### Operators

When enabled, all operators are wrapped if a line was printed before the first operator.

Since 1.7

Example 2.554. Operators (wrap on demand)

    while (
        beleg.x() == null || beleg.x().isValidated()
        || beleg.getVerifier().getVerfication() == null
        || beleg.getVerifier().getName().length() == 0
    ) {
        ...
    }

Example 2.555. Operators (wrap all when first wrapped)

    while (
        beleg.x() == null
        || beleg.x().isValidated()
        || beleg.getVerifier().getVerfication() == null
        || beleg.getVerifier().getName().length() == 0
    ) {
        ...
    }

Related options:

- "Wrap all parameters when first wrapped"
- "Wrap after left parentheses when exceed"

###### Ternary expression colon (`:`)

When enabled, the ternary colon will be wrapped when a line break occured before the ternary question.

Since 1.3

Example 2.556. Wrapped ternary question

    int spacesLength = (tabNumber == 0)
        ? spacesCount : (spacesCount - tabLength);

Example 2.557. Wrapped ternary question, wrap on-demand for colon

    int spacesLength = (tabNumber == 0)
        ? spacesCount
        : (spacesCount - tabLength);

#### 2.6.3.5. Never

Lets you disable line wrapping for certain elements.

Figure 2.39. Wrapping Never settings page

##### Chained method calls

Lets you specify whether wrapping along the dots of chained method calls should be disabled.

Since 1.0

Example 2.558. Wrapped chained method call

    message.format(ERROR_SOURCE_ADDRESS)
           .param(m_session.getAimName())
           .send();

Example 2.559. Chained method call (wrapping disabled)

    message.format(ERROR_SOURCE_ADDRESS).param(
        m_session.getAimName()).send();

Note how in the above example, wrapping does not occur along the dots of the chained method call, but after the left parenthesis!

##### Chained index operators

Lets you specify whether wrapping along the dots of chained index operators should be disabled.

Since 1.0

Example 2.560. Wrapped index operator

    String value = objects[i].names[j]
        .first[k];

Example 2.561. Index operator (wrapping disabled)

    String value =
        objects[i].names[j].first[k];

Note how in the above example wrapping does not occur along the dots of the index operator, but right after the assignment!

##### Qualifiers

Lets you specify whether wrapping along the dots of qualifiers should be disabled.

Since 1.0

Example 2.562. Wrapped qualifier

    com.company.project
    .MethodName.methodCall();

Example 2.563. Qualifier (wrapping disabled)

    com.company.project.MethodName
    .methodCall();

Note how in the above example, wrapping does not occur along the dots of the qualifier, but before the method call!

##### Dotted expression

Lets you specify whether wrapping along dotted expressions should be disabled. This option covers all dotted expressions not handled by the more specific options for chained method calls, index operators or qualifiers (see above).

The option is enabled by default for compatibility reasons. If you're serious about the maximal line length limit, we recommend to disable the option.

Since 1.5

Example 2.564. Wrapped dotted expression

    boolean test = ((com.foo.highfly.test.internal.Foo) container)     |
        .transportDebugFlag;                                           |
                                                                       |

Example 2.565. Dotted expression (wrapping disabled)

    boolean test =                                                     |
        ((com.foo.highfly.test.internal.Foo) container).transportDebugFlag;
                                                                       |