Jindent - Java Source Code Formatter http://www.jindent.com
 

previous topic  Previous:  Declarations Next:  Annotations   next topic

title
5.6.1.9.4 Method Calls

Wrap before left parentheses (

Wrap before left parentheses (

Controls how to wrap before left parentheses of method/constructor calls.

Please note:This setting does not affect method/constructor calls without any parameters.


Wrap always:

public void method()                    
{                                       
    callMethod                          
        (argumentOne, argumentTwo);     
    ...                                 
}                                       

This wrapping mode wraps always before left parentheses of method/constructor calls even if the line would fit into the specified maximal line length.
The wrapped line is indented by setting: "Indentation of wrapped left parentheses ("


Wrap never:

public void method()                    
{                                       
    callMethod(argumentOne, argumentTwo);
    ...                                 
}                                       

This wrapping mode never wraps before left parentheses of method/constructor calls even if the line does not fit into the specified maximal line length.


Wrap on demand:

public void method()               |
{                                  |
    callMethod                     |
        (argumentOne, argumentTwo);     
    ...                            |
}                                  |

This wrapping mode wraps on demand:
If the left parenthesis of method/constructor calls fits into specified maximal line length then it won't be wrapped. If it exceeds maximal line length the line will be wrapped though.


Wrapping mode if line exceeds works a bit different:
If the whole method/constructor call exceeds maximal line length then the line will be wrapped before its left parenthesis.


We assume the following input source code example which exceeds maximal line length:

public void method()               |
{                                  |
    callMethod(argumentOne, argumentTwo);
    ...                            |
}                                  |

In this example token argumentTwo exceeds the specified maximal line length, therefore we consider this case as 'the line exceeds maximal line length' and it will be wrapped after its left parenthesis:

public void method()                    |
{                                       |
    callMethod                          |
        (argumentOne, argumentTwo);     |
    ...                                 |
}                                       |

Indentation of wrapped line is done by setting: "Indentation of wrapped left parentheses ("

See also... See also: Indentation of wrapped left parentheses (




Indentation of wrapped left parentheses (

Indentation of wrapped left parentheses (

Indents wrapped left parentheses of method/constructor calls by a specified number of white spaces.

See also... See also: Wrap before left parentheses (




Wrap first argument

Wrap first argument

Controls how to wrap first argument of method/constructor calls.


Wrap always:

public void method()                    
{                                       
    callMethod(                         
        argumentOne, argumentTwo, argumentThree);
    ...                                 
}                                       

This wrapping mode wraps always the first argument of method/constructor calls even if the line would fit into the specified maximal line length.
The wrapped line is indented by setting: "Indentation of first wrapped argument"


Wrap never:

public void method()                    
{                                       
    callMethod(argumentOne, argumentTwo, argumentThree);
    ...                                 
}                                       

This wrapping mode never wraps first arguments of method/constructor calls even if the line does not fit into the specified maximal line length.


Wrap on demand:

public void method()                         |
{                                            |
    aPrettyLongObjectName.callMethod(        |
        argumentOne, argumentTwo);           |
    ...                                      |
}                                            |

This wrapping mode wraps on demand:
If the first method/constructor call argument fits into specified maximal line length then it won't be wrapped. If it exceeds maximal line length it will be wrapped though.


Wrapping mode if line exceeds works a bit different:
If the whole method/constructor call exceeds maximal line length then the first argument will be wrapped.


We assume the following input source code example which exceeds maximal line length:

public void method()                  |
{                                     |
    callMethod(argumentOne, argumentTwo);
    ...                               |
}                                     |

In this example token argumentTwo exceeds the specified maximal line length, therefore we consider this case as 'the line exceeds maximal line length' and first argument will be wrapped:

public void method()                  |
{                                     |
    callMethod(                       |
        argumentOne, argumentTwo);    |
    ...                               |
}                                     |

Indentation of wrapped line is done by setting: "Indentation of first wrapped argument"



Indentation of first wrapped argument

Indentation of first wrapped argument

Indents first wrapped argument of method/constructor calls by a specified number of white spaces.

See also... See also: Wrap first argument




Wrap all other arguments

Wrap all other arguments

Controls how to wrap arguments of method/constructor calls.


Wrap always:

public void method()                    
{                                       
    callMethod(argumentOne,             
               argumentTwo,             
               argumentThree);          
    ...                                 
}                                       

This wrapping mode wraps always arguments of method/constructor calls even if the line would fit into the specified maximal line length.
Wrapped arguments will be be aligned to its corresponding first argument.


Wrap never:

public void method()                    
{                                       
    callMethod(argumentOne, argumentTwo, argumentThree);
    ...                                 
}                                       

This wrapping mode never wraps arguments of method/constructor calls even if the line does not fit into the specified maximal line length.


Wrap on demand:

public void method()                    |
{                                       |
    callMethod(argumentOne, argumentTwo,
               argumentThree);          |
    ...                                 |
}                                       |

This wrapping mode wraps on demand:
If the arguments of method/constructor calls fit into specified maximal line length then they won't be wrapped. If they exceed maximal line length they will be wrapped though.


Wrapping mode if line exceeds works a bit different:
If the whole method/constructor call exceeds maximal line length then all arguments will be wrapped.


We assume the following input source code example which exceeds maximal line length:

public void method()                              |
{                                                 |
    callMethod(argumentOne, argumentTwo, argumentThree);
    ...                                           |
}                                                 |

In this example token argumentThree exceeds the specified maximal line length, therefore we consider this case as 'the line exceeds maximal line length' and all arguments will be wrapped:

public void method()                              |
{                                                 |
    callMethod(argumentOne,                       |
               argumentTwo,                       |
               argumentThree);                    |
    ...                                           |
}                                                 |



Wrap right parentheses )

Wrap right parentheses )

Controls how to wrap right parentheses of method/constructor calls.

Please note:This setting does not affect method/constructor calls without any parameters.


Wrap always:

public void method()                    
{                                       
    callMethod(argumentOne, argumentTwo 
    );                                  
    ...                                 
}                                       

This wrapping mode wraps always right parentheses of method/constructor calls even if the line would fit into the specified maximal line length.


Wrap never:

public void method()                    
{                                       
    callMethod(argumentOne, argumentTwo);
    ...                                 
}                                       

This wrapping mode never wraps right parentheses of method/constructor calls even if the line does not fit into the specified maximal line length.


Wrap on demand:

public void method()                   |
{                                      |
    callMethod(argumentOne, argumentTwo 
    );                                 |
    ...                                |
}                                      |

This wrapping mode wraps on demand:
If the right parenthesis of method/constructor calls fits into specified maximal line length then it won't be wrapped. If it exceeds maximal line length the right parenthesis will be wrapped to a new line though.


Wrapping mode if line exceeds works a bit different:
If the whole method/constructor call exceeds maximal line length then the line will be wrapped before its right parenthesis.


We assume the following input source code example which exceeds maximal line length:

public void method()                         |
{                                            |
    callMethod(argumentOne, argumentTwo, argumentThree);
    ...                                      |
}                                            |

In this example token argumentThree exceeds the specified maximal line length, therefore we consider this case as 'the line exceeds maximal line length' and right parenthesis will be wrapped:

public void method()                                             |
{                                                                |
    callMethod(                                                  |
        argumentOne,                                             |
        argumentTwo,                                             |
        argumentThree                                            |
    );                                                           |
    ...                                                          |
}                                                                |
In this example we additionally set "Wrap first argument" and "Wrap right parentheses )" to if line exceeds too.



Allow wrapping of first argument

Allow wrapping of first argument

Determines whether line breaks are allowed before first arguments of nested method calls or not.
A 'nested method call' is a method call surrounded by another call, condition or expression.


Example of nested method call:

public void method()                    
{                                       
    callMethod(argumentOne,             
               argumentTwo,             
               callAnotherMethod(a, b)    // this is a nested method call
    );                                  
    ...                                 
}                                       


Allow wrapping of first argument in nested calls:

public void method()                                             |
{                                                                |
    callMethod(argumentOne,                                      |
               argumentTwo,                                      |
               callAnotherMethod(                                |
                   "a long string which cannot be wrapped",      |
                   anotherArgument);                             |
    );                                                           |
    ...                                                          |
}                                                                |

Indentation of wrapped line is done by setting: "General indentation size"


Do not allow wrapping of first argument in nested calls:

public void method()                                             |
{                                                                |
    callMethod(argumentOne,                                      |
               argumentTwo,                                      |
               callAnotherMethod("a long string which cannot be wrapped",
                                 anotherArgument);               |
    );                                                           |
    ...                                                          |
}                                                                |

Indentation of wrapped line is done by setting: "General indentation size"



Wrap chained constructor and method calls on demand

Wrap chained constructor and method calls on demand

Determines whether line breaks are allowed in chained method calls or not.


Allow wrapping of chained method calls:

public void method()                                   |
{                                                      |
    mypackage.jindent.utils.                           |
         .ClassName.staticMethodCall(a, b);            |
    ...                                                |
}                                                      |

Indentation of wrapped line is done by setting: "General indentation size"


Do not allow wrapping of chained method calls:

public void method()                                   |
{                                                      |
    mypackage.jindent.utils.ClassName.staticMethodCall(a, b);
    ...                                                |
}                                                      |