<HTML> <HEAD> <TITLE>pretty.settings</TITLE> <STYLE TYPE="text/css"><!-- .syntax0 { color: #000000; } .syntax1 { color: #006666; font-style: italic; } .syntax2 { color: #990033; font-style: italic; } .syntax3 { color: #404040; } .syntax4 { color: #404040; } .syntax5 { color: #990033; font-weight: bold; font-style: italic; } .syntax6 { color: #000000; font-weight: bold; } .syntax7 { color: #660066; font-weight: bold; } .syntax8 { color: #000066; font-weight: bold; } .syntax9 { color: #000066; } .syntax10 { color: #5e5e5e; font-weight: bold; } .syntax11 { color: #000000; } .syntax12 { color: #666600; } .syntax13 { color: #ff0000; } .gutter { background: #ffffff; color: #000000; } .gutterH { background: #ffffff; color: #000066; } --> </STYLE> </HEAD> <BODY BGCOLOR="#FFFFFF"> <PRE><SPAN CLASS="gutter"> 1:</SPAN><SPAN CLASS="syntax1"># Version</SPAN> <SPAN CLASS="gutter"> 2:</SPAN><SPAN CLASS="syntax6">version</SPAN>=<SPAN CLASS="syntax12">3.8</SPAN> <SPAN CLASS="gutter"> 3:</SPAN> <SPAN CLASS="gutter"> 4:</SPAN><SPAN CLASS="syntax1"># This is the number of characters to indent for each block.</SPAN> <SPAN CLASS="gutterH"> 5:</SPAN><SPAN CLASS="syntax6">indent</SPAN>=<SPAN CLASS="syntax12">4</SPAN> <SPAN CLASS="gutter"> 6:</SPAN> <SPAN CLASS="gutter"> 7:</SPAN><SPAN CLASS="syntax1"># This is the number of characters to indent for each block.</SPAN> <SPAN CLASS="gutter"> 8:</SPAN><SPAN CLASS="syntax1"># The character used to indent each block</SPAN> <SPAN CLASS="gutter"> 9:</SPAN><SPAN CLASS="syntax1"># * tab - use tabs to indent</SPAN> <SPAN CLASS="gutterH"> 10:</SPAN><SPAN CLASS="syntax1"># * space - use spaces to indent</SPAN> <SPAN CLASS="gutter"> 11:</SPAN><SPAN CLASS="syntax6">indent.char</SPAN>=space <SPAN CLASS="gutter"> 12:</SPAN> <SPAN CLASS="gutter"> 13:</SPAN><SPAN CLASS="syntax1"># The following parameter should be changed to true if you</SPAN> <SPAN CLASS="gutter"> 14:</SPAN><SPAN CLASS="syntax1"># like your parens to have a space before and after them</SPAN> <SPAN CLASS="gutterH"> 15:</SPAN><SPAN CLASS="syntax1"># if ( x == y ) //expr.space=true</SPAN> <SPAN CLASS="gutter"> 16:</SPAN><SPAN CLASS="syntax1"># if (x == y) //expr.space=false</SPAN> <SPAN CLASS="gutter"> 17:</SPAN><SPAN CLASS="syntax6">expr.space</SPAN>=false <SPAN CLASS="gutter"> 18:</SPAN> <SPAN CLASS="gutter"> 19:</SPAN><SPAN CLASS="syntax1"># The following parameter is the minimum number of blank lines</SPAN> <SPAN CLASS="gutterH"> 20:</SPAN><SPAN CLASS="syntax1"># between methods, nested classes, and nested interfaces.</SPAN> <SPAN CLASS="gutter"> 21:</SPAN><SPAN CLASS="syntax1"># It is also the number of lines before and after</SPAN> <SPAN CLASS="gutter"> 22:</SPAN><SPAN CLASS="syntax1"># field declarations, though field declarations will have</SPAN> <SPAN CLASS="gutter"> 23:</SPAN><SPAN CLASS="syntax1"># what ever spacing you used.</SPAN> <SPAN CLASS="gutter"> 24:</SPAN><SPAN CLASS="syntax1"># Note that this is a minimum. If your code already</SPAN> <SPAN CLASS="gutterH"> 25:</SPAN><SPAN CLASS="syntax1"># has more space between methods, then it won't shrink</SPAN> <SPAN CLASS="gutter"> 26:</SPAN><SPAN CLASS="syntax1"># the number of blank lines.</SPAN> <SPAN CLASS="gutter"> 27:</SPAN><SPAN CLASS="syntax6">lines.between</SPAN>=<SPAN CLASS="syntax12">2</SPAN> <SPAN CLASS="gutter"> 28:</SPAN> <SPAN CLASS="gutter"> 29:</SPAN><SPAN CLASS="syntax1"># Is there a space after the cast</SPAN> <SPAN CLASS="gutterH"> 30:</SPAN><SPAN CLASS="syntax6">cast.space</SPAN>=true <SPAN CLASS="gutter"> 31:</SPAN> <SPAN CLASS="gutter"> 32:</SPAN><SPAN CLASS="syntax1"># Do we force a space after a cast?</SPAN> <SPAN CLASS="gutter"> 33:</SPAN><SPAN CLASS="syntax6">cast.force.nospace</SPAN>=false <SPAN CLASS="gutter"> 34:</SPAN> <SPAN CLASS="gutterH"> 35:</SPAN><SPAN CLASS="syntax1"># What do you do when a newline is unexpectedly encountered?</SPAN> <SPAN CLASS="gutter"> 36:</SPAN><SPAN CLASS="syntax1"># * double - The pretty printer inserts 2 indents</SPAN> <SPAN CLASS="gutter"> 37:</SPAN><SPAN CLASS="syntax1"># * single - The pretty printer inserts 1 indent</SPAN> <SPAN CLASS="gutter"> 38:</SPAN><SPAN CLASS="syntax1"># * param - Like single, except method arguments are indented to the parens</SPAN> <SPAN CLASS="gutter"> 39:</SPAN><SPAN CLASS="syntax6">surprise.return</SPAN>=double <SPAN CLASS="gutterH"> 40:</SPAN> <SPAN CLASS="gutter"> 41:</SPAN><SPAN CLASS="syntax1"># Should throws part of a method/constructor declaration always be</SPAN> <SPAN CLASS="gutter"> 42:</SPAN><SPAN CLASS="syntax1"># on its own line?</SPAN> <SPAN CLASS="gutter"> 43:</SPAN><SPAN CLASS="syntax6">throws.newline</SPAN>=false <SPAN CLASS="gutter"> 44:</SPAN> <SPAN CLASS="gutterH"> 45:</SPAN><SPAN CLASS="syntax1"># When the catch.start.line setting is true, catch statements look like</SPAN> <SPAN CLASS="gutter"> 46:</SPAN><SPAN CLASS="syntax1"># try {</SPAN> <SPAN CLASS="gutter"> 47:</SPAN><SPAN CLASS="syntax1"># // Something here</SPAN> <SPAN CLASS="gutter"> 48:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutter"> 49:</SPAN><SPAN CLASS="syntax1"># catch (IOException ioe) {</SPAN> <SPAN CLASS="gutterH"> 50:</SPAN><SPAN CLASS="syntax1"># // Something here</SPAN> <SPAN CLASS="gutter"> 51:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutter"> 52:</SPAN><SPAN CLASS="syntax1"># When the catch.start.line setting is false, catch statements look like</SPAN> <SPAN CLASS="gutter"> 53:</SPAN><SPAN CLASS="syntax1"># try {</SPAN> <SPAN CLASS="gutter"> 54:</SPAN><SPAN CLASS="syntax1"># // Something here</SPAN> <SPAN CLASS="gutterH"> 55:</SPAN><SPAN CLASS="syntax1"># } catch (IOException ioe) {</SPAN> <SPAN CLASS="gutter"> 56:</SPAN><SPAN CLASS="syntax1"># // Something here</SPAN> <SPAN CLASS="gutter"> 57:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutter"> 58:</SPAN><SPAN CLASS="syntax6">catch.start.line</SPAN>=false <SPAN CLASS="gutter"> 59:</SPAN> <SPAN CLASS="gutterH"> 60:</SPAN><SPAN CLASS="syntax1"># Should if/then/else statements look like</SPAN> <SPAN CLASS="gutter"> 61:</SPAN><SPAN CLASS="syntax1"># (true) is:</SPAN> <SPAN CLASS="gutter"> 62:</SPAN><SPAN CLASS="syntax1"># if (someTest()) {</SPAN> <SPAN CLASS="gutter"> 63:</SPAN><SPAN CLASS="syntax1"># // Something here</SPAN> <SPAN CLASS="gutter"> 64:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutterH"> 65:</SPAN><SPAN CLASS="syntax1"># else {</SPAN> <SPAN CLASS="gutter"> 66:</SPAN><SPAN CLASS="syntax1"># // Something here</SPAN> <SPAN CLASS="gutter"> 67:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutter"> 68:</SPAN><SPAN CLASS="syntax1"># (false) is:</SPAN> <SPAN CLASS="gutter"> 69:</SPAN><SPAN CLASS="syntax1"># if (someTest()) {</SPAN> <SPAN CLASS="gutterH"> 70:</SPAN><SPAN CLASS="syntax1"># // Something here</SPAN> <SPAN CLASS="gutter"> 71:</SPAN><SPAN CLASS="syntax1"># } else {</SPAN> <SPAN CLASS="gutter"> 72:</SPAN><SPAN CLASS="syntax1"># // Something here</SPAN> <SPAN CLASS="gutter"> 73:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutter"> 74:</SPAN><SPAN CLASS="syntax6">else.start.line</SPAN>=false <SPAN CLASS="gutterH"> 75:</SPAN> <SPAN CLASS="gutter"> 76:</SPAN><SPAN CLASS="syntax1"># Indent the name of the field (instance variable or class</SPAN> <SPAN CLASS="gutter"> 77:</SPAN><SPAN CLASS="syntax1"># variable) to this column (-1 for just one space)</SPAN> <SPAN CLASS="gutter"> 78:</SPAN><SPAN CLASS="syntax6">field.name.indent</SPAN>=<SPAN CLASS="syntax12">-1</SPAN> <SPAN CLASS="gutter"> 79:</SPAN> <SPAN CLASS="gutterH"> 80:</SPAN><SPAN CLASS="syntax1"># End of line character(s) - either CR, CRNL, or NL</SPAN> <SPAN CLASS="gutter"> 81:</SPAN><SPAN CLASS="syntax1"># * CR - carriage return</SPAN> <SPAN CLASS="gutter"> 82:</SPAN><SPAN CLASS="syntax1"># * NL - newline</SPAN> <SPAN CLASS="gutter"> 83:</SPAN><SPAN CLASS="syntax1"># * CRNL - carriage return and newline</SPAN> <SPAN CLASS="gutter"> 84:</SPAN><SPAN CLASS="syntax6">end.line</SPAN>=CRNL <SPAN CLASS="gutterH"> 85:</SPAN> <SPAN CLASS="gutter"> 86:</SPAN><SPAN CLASS="syntax1"># This features sprecifies how to space out a field or a local</SPAN> <SPAN CLASS="gutter"> 87:</SPAN><SPAN CLASS="syntax1"># variable declaration.</SPAN> <SPAN CLASS="gutter"> 88:</SPAN><SPAN CLASS="syntax1"># * single - a space between the modifiers, the type, the name and the initializer</SPAN> <SPAN CLASS="gutter"> 89:</SPAN><SPAN CLASS="syntax1"># * dynamic - determine the spacing between the modifiers, type, name, and initializers so everything lines up</SPAN> <SPAN CLASS="gutterH"> 90:</SPAN><SPAN CLASS="syntax1"># * javadoc.dynamic - determine the spacing between the modifiers, type, name, and initializers so everything lines up, except when the field is prefixed by a javadoc comment</SPAN> <SPAN CLASS="gutter"> 91:</SPAN><SPAN CLASS="syntax1"># * align.equals - align the equals statements of field declaration, but nothing else</SPAN> <SPAN CLASS="gutter"> 92:</SPAN><SPAN CLASS="syntax6">variable.spacing</SPAN>=single <SPAN CLASS="gutter"> 93:</SPAN> <SPAN CLASS="gutter"> 94:</SPAN><SPAN CLASS="syntax1"># When a dynamic field spacing is used, this value specifies</SPAN> <SPAN CLASS="gutterH"> 95:</SPAN><SPAN CLASS="syntax1"># the number of additional spaces to add between the modifiers,</SPAN> <SPAN CLASS="gutter"> 96:</SPAN><SPAN CLASS="syntax1"># type, name, and initializer.</SPAN> <SPAN CLASS="gutter"> 97:</SPAN><SPAN CLASS="syntax6">dynamic.variable.spacing</SPAN>=<SPAN CLASS="syntax12">1</SPAN> <SPAN CLASS="gutter"> 98:</SPAN> <SPAN CLASS="gutter"> 99:</SPAN><SPAN CLASS="syntax1"># Should the local variables be aligned with the { and }</SPAN> <SPAN CLASS="gutterH"> 100:</SPAN><SPAN CLASS="syntax1"># or should they be indented to align with the other code?</SPAN> <SPAN CLASS="gutter"> 101:</SPAN><SPAN CLASS="syntax1"># false means align with the code, true means align</SPAN> <SPAN CLASS="gutter"> 102:</SPAN><SPAN CLASS="syntax1"># with the { }</SPAN> <SPAN CLASS="gutter"> 103:</SPAN><SPAN CLASS="syntax6">variable.align.with.block</SPAN>=false <SPAN CLASS="gutter"> 104:</SPAN> <SPAN CLASS="gutterH"> 105:</SPAN><SPAN CLASS="syntax1"># The amount to indent a case statement (in terms of indent.char)</SPAN> <SPAN CLASS="gutter"> 106:</SPAN><SPAN CLASS="syntax6">case.indent</SPAN>=<SPAN CLASS="syntax12">4</SPAN> <SPAN CLASS="gutter"> 107:</SPAN> <SPAN CLASS="gutter"> 108:</SPAN><SPAN CLASS="syntax1"># This determines if there should be a space after keywords</SPAN> <SPAN CLASS="gutter"> 109:</SPAN><SPAN CLASS="syntax1"># such as if, while, or for. When this value is true, you get:</SPAN> <SPAN CLASS="gutterH"> 110:</SPAN><SPAN CLASS="syntax1"># if (true) {</SPAN> <SPAN CLASS="gutter"> 111:</SPAN><SPAN CLASS="syntax1"># // Do something</SPAN> <SPAN CLASS="gutter"> 112:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutter"> 113:</SPAN><SPAN CLASS="syntax1"># When this value is false, you get:</SPAN> <SPAN CLASS="gutter"> 114:</SPAN><SPAN CLASS="syntax1"># if(true) {</SPAN> <SPAN CLASS="gutterH"> 115:</SPAN><SPAN CLASS="syntax1"># // Do something</SPAN> <SPAN CLASS="gutter"> 116:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutter"> 117:</SPAN><SPAN CLASS="syntax6">keyword.space</SPAN>=true <SPAN CLASS="gutter"> 118:</SPAN> <SPAN CLASS="gutter"> 119:</SPAN><SPAN CLASS="syntax1"># Do we force a blank line before and after local variable declarations?</SPAN> <SPAN CLASS="gutterH"> 120:</SPAN><SPAN CLASS="syntax6">insert.space.around.local.variables</SPAN>=false <SPAN CLASS="gutter"> 121:</SPAN> <SPAN CLASS="gutter"> 122:</SPAN><SPAN CLASS="syntax1"># This is the number of lines to insert after a package statement.</SPAN> <SPAN CLASS="gutter"> 123:</SPAN><SPAN CLASS="syntax6">lines.after.package</SPAN>=<SPAN CLASS="syntax12">1</SPAN> <SPAN CLASS="gutter"> 124:</SPAN> <SPAN CLASS="gutterH"> 125:</SPAN><SPAN CLASS="syntax1"># Do we keep all the newlines around imports?</SPAN> <SPAN CLASS="gutter"> 126:</SPAN><SPAN CLASS="syntax6">maintain.newlines.around.imports</SPAN>=true <SPAN CLASS="gutter"> 127:</SPAN> <SPAN CLASS="gutter"> 128:</SPAN><SPAN CLASS="syntax1"># This is the number of lines to insert before a class.</SPAN> <SPAN CLASS="gutter"> 129:</SPAN><SPAN CLASS="syntax6">lines.before.class</SPAN>=<SPAN CLASS="syntax12">0</SPAN> <SPAN CLASS="gutterH"> 130:</SPAN> <SPAN CLASS="gutter"> 131:</SPAN><SPAN CLASS="syntax1"># Style for { and }</SPAN> <SPAN CLASS="gutter"> 132:</SPAN><SPAN CLASS="syntax1"># C style means that { is at the end of the line</SPAN> <SPAN CLASS="gutter"> 133:</SPAN><SPAN CLASS="syntax1"># and } is on a line by itself. For example,</SPAN> <SPAN CLASS="gutter"> 134:</SPAN><SPAN CLASS="syntax1"># if (myTest) {</SPAN> <SPAN CLASS="gutterH"> 135:</SPAN><SPAN CLASS="syntax1"># // This is c style</SPAN> <SPAN CLASS="gutter"> 136:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutter"> 137:</SPAN><SPAN CLASS="syntax1"># PASCAL style means both { and } are on lines</SPAN> <SPAN CLASS="gutter"> 138:</SPAN><SPAN CLASS="syntax1"># by themselves. For example,</SPAN> <SPAN CLASS="gutter"> 139:</SPAN><SPAN CLASS="syntax1"># if (myTest)</SPAN> <SPAN CLASS="gutterH"> 140:</SPAN><SPAN CLASS="syntax1"># {</SPAN> <SPAN CLASS="gutter"> 141:</SPAN><SPAN CLASS="syntax1"># // This is PASCAL style</SPAN> <SPAN CLASS="gutter"> 142:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutter"> 143:</SPAN><SPAN CLASS="syntax1"># EMACS style means both { and } are on lines</SPAN> <SPAN CLASS="gutter"> 144:</SPAN><SPAN CLASS="syntax1"># by themselves and indented one level.</SPAN> <SPAN CLASS="gutterH"> 145:</SPAN><SPAN CLASS="syntax1"># For example,</SPAN> <SPAN CLASS="gutter"> 146:</SPAN><SPAN CLASS="syntax1"># if (myTest)</SPAN> <SPAN CLASS="gutter"> 147:</SPAN><SPAN CLASS="syntax1"># {</SPAN> <SPAN CLASS="gutter"> 148:</SPAN><SPAN CLASS="syntax1"># // This is EMACS style</SPAN> <SPAN CLASS="gutter"> 149:</SPAN><SPAN CLASS="syntax1"># }</SPAN> <SPAN CLASS="gutterH"> 150:</SPAN><SPAN CLASS="syntax1"># * C - C style</SPAN> <SPAN CLASS="gutter"> 151:</SPAN><SPAN CLASS="syntax1"># * PASCAL - PASCAL style</SPAN> <SPAN CLASS="gutter"> 152:</SPAN><SPAN CLASS="syntax1"># * EMACS - EMACS style</SPAN> <SPAN CLASS="gutter"> 153:</SPAN><SPAN CLASS="syntax6">block.style</SPAN>=C <SPAN CLASS="gutter"> 154:</SPAN> <SPAN CLASS="gutterH"> 155:</SPAN><SPAN CLASS="syntax1"># To handle sun's coding standard, you want the method to begin</SPAN> <SPAN CLASS="gutter"> 156:</SPAN><SPAN CLASS="syntax1"># with a PASCAL coding style and the {} beneath that to be C style.</SPAN> <SPAN CLASS="gutter"> 157:</SPAN><SPAN CLASS="syntax1"># This parameter allows you to set the method style different</SPAN> <SPAN CLASS="gutter"> 158:</SPAN><SPAN CLASS="syntax1"># from the rest.</SPAN> <SPAN CLASS="gutter"> 159:</SPAN><SPAN CLASS="syntax1"># * C - C style</SPAN> <SPAN CLASS="gutterH"> 160:</SPAN><SPAN CLASS="syntax1"># * PASCAL - PASCAL style</SPAN> <SPAN CLASS="gutter"> 161:</SPAN><SPAN CLASS="syntax1"># * EMACS - EMACS style</SPAN> <SPAN CLASS="gutter"> 162:</SPAN><SPAN CLASS="syntax6">method.block.style</SPAN>=C <SPAN CLASS="gutter"> 163:</SPAN> <SPAN CLASS="gutter"> 164:</SPAN><SPAN CLASS="syntax1"># To handle sun's coding standard, you want the class to begin</SPAN> <SPAN CLASS="gutterH"> 165:</SPAN><SPAN CLASS="syntax1"># with a PASCAL coding style and the {} beneath that to be C style.</SPAN> <SPAN CLASS="gutter"> 166:</SPAN><SPAN CLASS="syntax1"># This parameter allows you to set the class style different</SPAN> <SPAN CLASS="gutter"> 167:</SPAN><SPAN CLASS="syntax1"># from the rest.</SPAN> <SPAN CLASS="gutter"> 168:</SPAN><SPAN CLASS="syntax1"># * C - C style</SPAN> <SPAN CLASS="gutter"> 169:</SPAN><SPAN CLASS="syntax1"># * PASCAL - PASCAL style</SPAN> <SPAN CLASS="gutterH"> 170:</SPAN><SPAN CLASS="syntax1"># * EMACS - EMACS style</SPAN> <SPAN CLASS="gutter"> 171:</SPAN><SPAN CLASS="syntax6">class.block.style</SPAN>=C <SPAN CLASS="gutter"> 172:</SPAN> <SPAN CLASS="gutter"> 173:</SPAN><SPAN CLASS="syntax1"># Do we force if and while and for statements to have a block? { ... }</SPAN> <SPAN CLASS="gutter"> 174:</SPAN><SPAN CLASS="syntax6">force.block</SPAN>=true <SPAN CLASS="gutterH"> 175:</SPAN> <SPAN CLASS="gutter"> 176:</SPAN><SPAN CLASS="syntax1"># Empty methods and constructors remain on a single line</SPAN> <SPAN CLASS="gutter"> 177:</SPAN><SPAN CLASS="syntax6">empty.block.single.line</SPAN>=true <SPAN CLASS="gutter"> 178:</SPAN> <SPAN CLASS="gutter"> 179:</SPAN><SPAN CLASS="syntax1"># Remove {} when they surround only 1 statement</SPAN> <SPAN CLASS="gutterH"> 180:</SPAN><SPAN CLASS="syntax6">remove.excess.blocks</SPAN>=false <SPAN CLASS="gutter"> 181:</SPAN> <SPAN CLASS="gutter"> 182:</SPAN><SPAN CLASS="syntax1"># Should each single line comment be indented a certain number of spaces</SPAN> <SPAN CLASS="gutter"> 183:</SPAN><SPAN CLASS="syntax1"># from the margin? For this to work right be sure to indent each line with</SPAN> <SPAN CLASS="gutter"> 184:</SPAN><SPAN CLASS="syntax1"># spaces.</SPAN> <SPAN CLASS="gutterH"> 185:</SPAN><SPAN CLASS="syntax6">singleline.comment.ownline</SPAN>=true <SPAN CLASS="gutter"> 186:</SPAN> <SPAN CLASS="gutter"> 187:</SPAN><SPAN CLASS="syntax1"># Absolute indent before a single line comment.</SPAN> <SPAN CLASS="gutter"> 188:</SPAN><SPAN CLASS="syntax6">singleline.comment.absoluteindent</SPAN>=<SPAN CLASS="syntax12">0</SPAN> <SPAN CLASS="gutter"> 189:</SPAN> <SPAN CLASS="gutterH"> 190:</SPAN><SPAN CLASS="syntax1"># Space used before the start of a single line</SPAN> <SPAN CLASS="gutter"> 191:</SPAN><SPAN CLASS="syntax1"># from the end of the code. This value is used</SPAN> <SPAN CLASS="gutter"> 192:</SPAN><SPAN CLASS="syntax1"># to determine the number of spaces and how these</SPAN> <SPAN CLASS="gutter"> 193:</SPAN><SPAN CLASS="syntax1"># spaces are used based on the next few settings.</SPAN> <SPAN CLASS="gutter"> 194:</SPAN><SPAN CLASS="syntax6">singleline.comment.incrementalindent</SPAN>=<SPAN CLASS="syntax12">0</SPAN> <SPAN CLASS="gutterH"> 195:</SPAN> <SPAN CLASS="gutter"> 196:</SPAN><SPAN CLASS="syntax1"># This feature describes how the pretty printer should</SPAN> <SPAN CLASS="gutter"> 197:</SPAN><SPAN CLASS="syntax1"># indent single line comments (//) that share the line</SPAN> <SPAN CLASS="gutter"> 198:</SPAN><SPAN CLASS="syntax1"># with source code. The two choices are incremental and absolute.</SPAN> <SPAN CLASS="gutter"> 199:</SPAN><SPAN CLASS="syntax1"># * incremental - use an incremental indent</SPAN> <SPAN CLASS="gutterH"> 200:</SPAN><SPAN CLASS="syntax1"># * absolute - use the absolute indent level</SPAN> <SPAN CLASS="gutter"> 201:</SPAN><SPAN CLASS="syntax6">singleline.comment.indentstyle.shared</SPAN>=incremental <SPAN CLASS="gutter"> 202:</SPAN> <SPAN CLASS="gutter"> 203:</SPAN><SPAN CLASS="syntax1"># This feature describes how the pretty printer should</SPAN> <SPAN CLASS="gutter"> 204:</SPAN><SPAN CLASS="syntax1"># indent single line comments (//) that are on their</SPAN> <SPAN CLASS="gutterH"> 205:</SPAN><SPAN CLASS="syntax1"># own line. The two choices are code and absolute.</SPAN> <SPAN CLASS="gutter"> 206:</SPAN><SPAN CLASS="syntax1"># * code - use the same indent as the current code</SPAN> <SPAN CLASS="gutter"> 207:</SPAN><SPAN CLASS="syntax1"># * absolute - use the absolute indent level</SPAN> <SPAN CLASS="gutter"> 208:</SPAN><SPAN CLASS="syntax6">singleline.comment.indentstyle.ownline</SPAN>=code <SPAN CLASS="gutter"> 209:</SPAN> <SPAN CLASS="gutterH"> 210:</SPAN><SPAN CLASS="syntax1"># How to format C Style comments. Valid values are:</SPAN> <SPAN CLASS="gutter"> 211:</SPAN><SPAN CLASS="syntax1"># * leave - leave alone</SPAN> <SPAN CLASS="gutter"> 212:</SPAN><SPAN CLASS="syntax1"># * maintain.space.star - there is a row of stars to the right, but we maintain the spaces after it</SPAN> <SPAN CLASS="gutter"> 213:</SPAN><SPAN CLASS="syntax1"># * align.star - place a row of stars to the right and align on those</SPAN> <SPAN CLASS="gutter"> 214:</SPAN><SPAN CLASS="syntax1"># * align.blank - just align the comments to the right (no star)</SPAN> <SPAN CLASS="gutterH"> 215:</SPAN><SPAN CLASS="syntax6">c.style.format</SPAN>=align.star <SPAN CLASS="gutter"> 216:</SPAN> <SPAN CLASS="gutter"> 217:</SPAN><SPAN CLASS="syntax1"># For one of the methods above that use the align type, this is</SPAN> <SPAN CLASS="gutter"> 218:</SPAN><SPAN CLASS="syntax1"># the number of spaces to include after the * or blank</SPAN> <SPAN CLASS="gutter"> 219:</SPAN><SPAN CLASS="syntax6">c.style.indent</SPAN>=<SPAN CLASS="syntax12">2</SPAN> <SPAN CLASS="gutterH"> 220:</SPAN> <SPAN CLASS="gutter"> 221:</SPAN><SPAN CLASS="syntax1"># Limits the level that javadoc comments are forced</SPAN> <SPAN CLASS="gutter"> 222:</SPAN><SPAN CLASS="syntax1"># into the document. The following are valid</SPAN> <SPAN CLASS="gutter"> 223:</SPAN><SPAN CLASS="syntax1"># levels:</SPAN> <SPAN CLASS="gutter"> 224:</SPAN><SPAN CLASS="syntax1"># method.minimum applies to constructors and methods</SPAN> <SPAN CLASS="gutterH"> 225:</SPAN><SPAN CLASS="syntax1"># * all - all items must have javadoc</SPAN> <SPAN CLASS="gutter"> 226:</SPAN><SPAN CLASS="syntax1"># * private - same as all</SPAN> <SPAN CLASS="gutter"> 227:</SPAN><SPAN CLASS="syntax1"># * package - all items except private items must have javadoc</SPAN> <SPAN CLASS="gutter"> 228:</SPAN><SPAN CLASS="syntax1"># * default - same as package</SPAN> <SPAN CLASS="gutter"> 229:</SPAN><SPAN CLASS="syntax1"># * protected - protected and public items must have javadoc</SPAN> <SPAN CLASS="gutterH"> 230:</SPAN><SPAN CLASS="syntax1"># * public - only public items must have javadoc</SPAN> <SPAN CLASS="gutter"> 231:</SPAN><SPAN CLASS="syntax1"># * none - nothing is required to have javadoc</SPAN> <SPAN CLASS="gutter"> 232:</SPAN><SPAN CLASS="syntax6">method.minimum</SPAN>=all <SPAN CLASS="gutter"> 233:</SPAN> <SPAN CLASS="gutter"> 234:</SPAN><SPAN CLASS="syntax1"># field.minimum applies to fields</SPAN> <SPAN CLASS="gutterH"> 235:</SPAN><SPAN CLASS="syntax1"># * all - all items must have javadoc</SPAN> <SPAN CLASS="gutter"> 236:</SPAN><SPAN CLASS="syntax1"># * private - same as all</SPAN> <SPAN CLASS="gutter"> 237:</SPAN><SPAN CLASS="syntax1"># * package - all items except private items must have javadoc</SPAN> <SPAN CLASS="gutter"> 238:</SPAN><SPAN CLASS="syntax1"># * default - same as package</SPAN> <SPAN CLASS="gutter"> 239:</SPAN><SPAN CLASS="syntax1"># * protected - protected and public items must have javadoc</SPAN> <SPAN CLASS="gutterH"> 240:</SPAN><SPAN CLASS="syntax1"># * public - only public items must have javadoc</SPAN> <SPAN CLASS="gutter"> 241:</SPAN><SPAN CLASS="syntax1"># * none - nothing is required to have javadoc</SPAN> <SPAN CLASS="gutter"> 242:</SPAN><SPAN CLASS="syntax6">field.minimum</SPAN>=protected <SPAN CLASS="gutter"> 243:</SPAN> <SPAN CLASS="gutter"> 244:</SPAN><SPAN CLASS="syntax1"># class.minimum applies to classes and interfaces</SPAN> <SPAN CLASS="gutterH"> 245:</SPAN><SPAN CLASS="syntax1"># * all - all items must have javadoc</SPAN> <SPAN CLASS="gutter"> 246:</SPAN><SPAN CLASS="syntax1"># * private - same as all</SPAN> <SPAN CLASS="gutter"> 247:</SPAN><SPAN CLASS="syntax1"># * package - all items except private items must have javadoc</SPAN> <SPAN CLASS="gutter"> 248:</SPAN><SPAN CLASS="syntax1"># * default - same as package</SPAN> <SPAN CLASS="gutter"> 249:</SPAN><SPAN CLASS="syntax1"># * protected - protected and public items must have javadoc</SPAN> <SPAN CLASS="gutterH"> 250:</SPAN><SPAN CLASS="syntax1"># * public - only public items must have javadoc</SPAN> <SPAN CLASS="gutter"> 251:</SPAN><SPAN CLASS="syntax1"># * none - nothing is required to have javadoc</SPAN> <SPAN CLASS="gutter"> 252:</SPAN><SPAN CLASS="syntax6">class.minimum</SPAN>=all <SPAN CLASS="gutter"> 253:</SPAN> <SPAN CLASS="gutter"> 254:</SPAN><SPAN CLASS="syntax1"># Star count for javadoc</SPAN> <SPAN CLASS="gutterH"> 255:</SPAN><SPAN CLASS="syntax6">javadoc.star</SPAN>=<SPAN CLASS="syntax12">2</SPAN> <SPAN CLASS="gutter"> 256:</SPAN> <SPAN CLASS="gutter"> 257:</SPAN><SPAN CLASS="syntax1"># Wordwrap length for javadoc. If the sum of the number of</SPAN> <SPAN CLASS="gutter"> 258:</SPAN><SPAN CLASS="syntax1"># characters on the line exceeds this value, then the javadoc</SPAN> <SPAN CLASS="gutter"> 259:</SPAN><SPAN CLASS="syntax1"># comment will be wordwrapped.</SPAN> <SPAN CLASS="gutterH"> 260:</SPAN><SPAN CLASS="syntax6">javadoc.wordwrap.max</SPAN>=<SPAN CLASS="syntax12">80</SPAN> <SPAN CLASS="gutter"> 261:</SPAN> <SPAN CLASS="gutter"> 262:</SPAN><SPAN CLASS="syntax1"># This feature keeps a method that is deeply indented from</SPAN> <SPAN CLASS="gutter"> 263:</SPAN><SPAN CLASS="syntax1"># only having a few words on each line. This feature requires</SPAN> <SPAN CLASS="gutter"> 264:</SPAN><SPAN CLASS="syntax1"># that there be this many characters after the comment starts</SPAN> <SPAN CLASS="gutterH"> 265:</SPAN><SPAN CLASS="syntax1"># before the javadoc comment is wordwrapped.</SPAN> <SPAN CLASS="gutter"> 266:</SPAN><SPAN CLASS="syntax6">javadoc.wordwrap.min</SPAN>=<SPAN CLASS="syntax12">40</SPAN> <SPAN CLASS="gutter"> 267:</SPAN> <SPAN CLASS="gutter"> 268:</SPAN><SPAN CLASS="syntax1"># Whether we put a space before the @</SPAN> <SPAN CLASS="gutter"> 269:</SPAN><SPAN CLASS="syntax6">space.before.javadoc</SPAN>=false <SPAN CLASS="gutterH"> 270:</SPAN> <SPAN CLASS="gutter"> 271:</SPAN><SPAN CLASS="syntax1"># Do you want to lineup the names and descriptions</SPAN> <SPAN CLASS="gutter"> 272:</SPAN><SPAN CLASS="syntax1"># in javadoc comments?</SPAN> <SPAN CLASS="gutter"> 273:</SPAN><SPAN CLASS="syntax6">javadoc.id.lineup</SPAN>=true <SPAN CLASS="gutter"> 274:</SPAN> <SPAN CLASS="gutterH"> 275:</SPAN><SPAN CLASS="syntax1"># How many spaces should javadoc comments be indented?</SPAN> <SPAN CLASS="gutter"> 276:</SPAN><SPAN CLASS="syntax6">javadoc.indent</SPAN>=<SPAN CLASS="syntax12">2</SPAN> <SPAN CLASS="gutter"> 277:</SPAN> <SPAN CLASS="gutter"> 278:</SPAN><SPAN CLASS="syntax1"># Wordwrap the javadoc comments</SPAN> <SPAN CLASS="gutter"> 279:</SPAN><SPAN CLASS="syntax6">reformat.comments</SPAN>=true <SPAN CLASS="gutterH"> 280:</SPAN> <SPAN CLASS="gutter"> 281:</SPAN><SPAN CLASS="syntax1"># What tag name should be used for exceptions</SPAN> <SPAN CLASS="gutter"> 282:</SPAN><SPAN CLASS="syntax6">exception.tag.name</SPAN>=@exception <SPAN CLASS="gutter"> 283:</SPAN> <SPAN CLASS="gutter"> 284:</SPAN><SPAN CLASS="syntax1"># Should inner classes be documented</SPAN> <SPAN CLASS="gutterH"> 285:</SPAN><SPAN CLASS="syntax6">document.nested.classes</SPAN>=true <SPAN CLASS="gutter"> 286:</SPAN> <SPAN CLASS="gutter"> 287:</SPAN><SPAN CLASS="syntax1"># Are javadoc comments allowed to be a single line long</SPAN> <SPAN CLASS="gutter"> 288:</SPAN><SPAN CLASS="syntax6">allow.singleline.javadoc</SPAN>=false <SPAN CLASS="gutter"> 289:</SPAN> <SPAN CLASS="gutterH"> 290:</SPAN><SPAN CLASS="syntax1"># Include javadoc comments where ever they appear. Javadoc comments</SPAN> <SPAN CLASS="gutter"> 291:</SPAN><SPAN CLASS="syntax1"># were originally only allowed to occur at a few places: immediately</SPAN> <SPAN CLASS="gutter"> 292:</SPAN><SPAN CLASS="syntax1"># before a method, immediately before a field, and immediately</SPAN> <SPAN CLASS="gutter"> 293:</SPAN><SPAN CLASS="syntax1"># before a class or interface. Since it is also common for people</SPAN> <SPAN CLASS="gutter"> 294:</SPAN><SPAN CLASS="syntax1"># to include the /*** pattern at the beginning of a file, this will be</SPAN> <SPAN CLASS="gutterH"> 295:</SPAN><SPAN CLASS="syntax1"># preserved as well.</SPAN> <SPAN CLASS="gutter"> 296:</SPAN><SPAN CLASS="syntax1"># This was the case until JBuilder pressed the javadoc style comment into</SPAN> <SPAN CLASS="gutter"> 297:</SPAN><SPAN CLASS="syntax1"># a new line of work - handling @todo tags. Suddenly it was permissible</SPAN> <SPAN CLASS="gutter"> 298:</SPAN><SPAN CLASS="syntax1"># to include javadoc comments anywhere in the file.</SPAN> <SPAN CLASS="gutter"> 299:</SPAN><SPAN CLASS="syntax1"># With keep.all.javadoc set to false, you get the original behavior. All</SPAN> <SPAN CLASS="gutterH"> 300:</SPAN><SPAN CLASS="syntax1"># javadoc comments that were not in the correct place were cleaned up for</SPAN> <SPAN CLASS="gutter"> 301:</SPAN><SPAN CLASS="syntax1"># you. With this set to true, you can place the @todo tags wherever you please.</SPAN> <SPAN CLASS="gutter"> 302:</SPAN><SPAN CLASS="syntax6">keep.all.javadoc</SPAN>=false <SPAN CLASS="gutter"> 303:</SPAN> <SPAN CLASS="gutter"> 304:</SPAN><SPAN CLASS="syntax1"># Default description of the class</SPAN> <SPAN CLASS="gutterH"> 305:</SPAN><SPAN CLASS="syntax6">class.descr</SPAN>=Description of the Class <SPAN CLASS="gutter"> 306:</SPAN> <SPAN CLASS="gutter"> 307:</SPAN><SPAN CLASS="syntax1"># Default description of the interface</SPAN> <SPAN CLASS="gutter"> 308:</SPAN><SPAN CLASS="syntax6">interface.descr</SPAN>=Description of the Interface <SPAN CLASS="gutter"> 309:</SPAN> <SPAN CLASS="gutterH"> 310:</SPAN><SPAN CLASS="syntax1"># Default description of the constructor {0} stands for the name</SPAN> <SPAN CLASS="gutter"> 311:</SPAN><SPAN CLASS="syntax1"># of the constructor</SPAN> <SPAN CLASS="gutter"> 312:</SPAN><SPAN CLASS="syntax6">constructor.descr</SPAN>=Constructor for the <SPAN CLASS="syntax8">{0}</SPAN> object <SPAN CLASS="gutter"> 313:</SPAN> <SPAN CLASS="gutter"> 314:</SPAN><SPAN CLASS="syntax1"># Default description of the method</SPAN> <SPAN CLASS="gutterH"> 315:</SPAN><SPAN CLASS="syntax6">method.descr</SPAN>=Description of the Method <SPAN CLASS="gutter"> 316:</SPAN> <SPAN CLASS="gutter"> 317:</SPAN><SPAN CLASS="syntax1"># Default description of the getter. {0} is the name of the</SPAN> <SPAN CLASS="gutter"> 318:</SPAN><SPAN CLASS="syntax1"># attribute, {1} is the name of the class, {2} is 'class'</SPAN> <SPAN CLASS="gutter"> 319:</SPAN><SPAN CLASS="syntax1"># or 'object' depending on whether it is static or not,</SPAN> <SPAN CLASS="gutterH"> 320:</SPAN><SPAN CLASS="syntax1"># {3} is the name of the attribute with the first letter lowercased</SPAN> <SPAN CLASS="gutter"> 321:</SPAN><SPAN CLASS="syntax1"># {4} is the name of the attribute broken into words</SPAN> <SPAN CLASS="gutter"> 322:</SPAN><SPAN CLASS="syntax6">getter.descr</SPAN>=Gets the <SPAN CLASS="syntax8">{3}</SPAN> attribute of the <SPAN CLASS="syntax8">{1}</SPAN> <SPAN CLASS="syntax8">{2}</SPAN> <SPAN CLASS="gutter"> 323:</SPAN> <SPAN CLASS="gutter"> 324:</SPAN><SPAN CLASS="syntax1"># Return description for getters. {0} is the name of the attribute,</SPAN> <SPAN CLASS="gutterH"> 325:</SPAN><SPAN CLASS="syntax1"># {3} is the name of the attribute with the first letter lowercased</SPAN> <SPAN CLASS="gutter"> 326:</SPAN><SPAN CLASS="syntax1"># {4} is the name of the attribute broken into words</SPAN> <SPAN CLASS="gutter"> 327:</SPAN><SPAN CLASS="syntax6">getter.return.descr</SPAN>=The <SPAN CLASS="syntax8">{3}</SPAN> value <SPAN CLASS="gutter"> 328:</SPAN> <SPAN CLASS="gutter"> 329:</SPAN><SPAN CLASS="syntax1"># Default description of the setter. {0} is the name of the</SPAN> <SPAN CLASS="gutterH"> 330:</SPAN><SPAN CLASS="syntax1"># attribute, {1} is the name of the class, {2} is 'class'</SPAN> <SPAN CLASS="gutter"> 331:</SPAN><SPAN CLASS="syntax1"># or 'object' depending on whether it is static or not,</SPAN> <SPAN CLASS="gutter"> 332:</SPAN><SPAN CLASS="syntax1"># {3} is the name of the attribute with the first letter lowercased</SPAN> <SPAN CLASS="gutter"> 333:</SPAN><SPAN CLASS="syntax1"># {4} is the name of the attribute broken into words</SPAN> <SPAN CLASS="gutter"> 334:</SPAN><SPAN CLASS="syntax6">setter.descr</SPAN>=Sets the <SPAN CLASS="syntax8">{3}</SPAN> attribute of the <SPAN CLASS="syntax8">{1}</SPAN> <SPAN CLASS="syntax8">{2}</SPAN> <SPAN CLASS="gutterH"> 335:</SPAN> <SPAN CLASS="gutter"> 336:</SPAN><SPAN CLASS="syntax1"># Parameter description for setters. {0} is the name of the attribute,</SPAN> <SPAN CLASS="gutter"> 337:</SPAN><SPAN CLASS="syntax1"># {3} is the name of the attribute with the first letter lowercased</SPAN> <SPAN CLASS="gutter"> 338:</SPAN><SPAN CLASS="syntax1"># {4} is the name of the attribute broken into words</SPAN> <SPAN CLASS="gutter"> 339:</SPAN><SPAN CLASS="syntax6">setter.param.descr</SPAN>=The new <SPAN CLASS="syntax8">{3}</SPAN> value <SPAN CLASS="gutterH"> 340:</SPAN> <SPAN CLASS="gutter"> 341:</SPAN><SPAN CLASS="syntax1"># Default field description</SPAN> <SPAN CLASS="gutter"> 342:</SPAN><SPAN CLASS="syntax6">field.descr</SPAN>=Description of the Field <SPAN CLASS="gutter"> 343:</SPAN> <SPAN CLASS="gutter"> 344:</SPAN><SPAN CLASS="syntax1"># Default description of the run method. {0} is not</SPAN> <SPAN CLASS="gutterH"> 345:</SPAN><SPAN CLASS="syntax1"># applicable, {1} is the name of the class, {2} is 'class'</SPAN> <SPAN CLASS="gutter"> 346:</SPAN><SPAN CLASS="syntax1"># or 'object' depending on whether it is static or not</SPAN> <SPAN CLASS="gutter"> 347:</SPAN><SPAN CLASS="syntax6">run.descr</SPAN>=Main processing method for the <SPAN CLASS="syntax8">{1}</SPAN> <SPAN CLASS="syntax8">{2}</SPAN> <SPAN CLASS="gutter"> 348:</SPAN> <SPAN CLASS="gutter"> 349:</SPAN><SPAN CLASS="syntax1"># Default description of the run method. {0} is not</SPAN> <SPAN CLASS="gutterH"> 350:</SPAN><SPAN CLASS="syntax1"># applicable, {1} is the name of the class, {2} is 'class'</SPAN> <SPAN CLASS="gutter"> 351:</SPAN><SPAN CLASS="syntax1"># or 'object' depending on whether it is static or not</SPAN> <SPAN CLASS="gutter"> 352:</SPAN><SPAN CLASS="syntax6">main.descr</SPAN>=The main program for the <SPAN CLASS="syntax8">{1}</SPAN> <SPAN CLASS="syntax8">{2}</SPAN> <SPAN CLASS="gutter"> 353:</SPAN> <SPAN CLASS="gutter"> 354:</SPAN><SPAN CLASS="syntax1"># Description of the main arguments</SPAN> <SPAN CLASS="gutterH"> 355:</SPAN><SPAN CLASS="syntax6">main.param.descr</SPAN>=The command line arguments <SPAN CLASS="gutter"> 356:</SPAN> <SPAN CLASS="gutter"> 357:</SPAN><SPAN CLASS="syntax1"># Default description of the add method. {0} is the name of the</SPAN> <SPAN CLASS="gutter"> 358:</SPAN><SPAN CLASS="syntax1"># attribute, {1} is the name of the class, {2} is 'class'</SPAN> <SPAN CLASS="gutter"> 359:</SPAN><SPAN CLASS="syntax1"># or 'object' depending on whether it is static or not,</SPAN> <SPAN CLASS="gutterH"> 360:</SPAN><SPAN CLASS="syntax1"># {3} is the name of the attribute with the first letter lowercased</SPAN> <SPAN CLASS="gutter"> 361:</SPAN><SPAN CLASS="syntax6">adder.descr</SPAN>=Adds a feature to the <SPAN CLASS="syntax8">{0}</SPAN> attribute of the <SPAN CLASS="syntax8">{1}</SPAN> <SPAN CLASS="syntax8">{2}</SPAN> <SPAN CLASS="gutter"> 362:</SPAN> <SPAN CLASS="gutter"> 363:</SPAN><SPAN CLASS="syntax1"># Description of the add argument</SPAN> <SPAN CLASS="gutter"> 364:</SPAN><SPAN CLASS="syntax6">adder.param.descr</SPAN>=The feature to be added to the <SPAN CLASS="syntax8">{0}</SPAN> attribute <SPAN CLASS="gutterH"> 365:</SPAN> <SPAN CLASS="gutter"> 366:</SPAN><SPAN CLASS="syntax1"># JUnit has a particular format for the names of methods.</SPAN> <SPAN CLASS="gutter"> 367:</SPAN><SPAN CLASS="syntax1"># These setup for the unit tests are done in a method named</SPAN> <SPAN CLASS="gutter"> 368:</SPAN><SPAN CLASS="syntax1"># setUp, the cleanup afterwards is done in tearDown, and</SPAN> <SPAN CLASS="gutter"> 369:</SPAN><SPAN CLASS="syntax1"># the unit tests all start with the word test. The following</SPAN> <SPAN CLASS="gutterH"> 370:</SPAN><SPAN CLASS="syntax1"># are the default descriptions of these methods.</SPAN> <SPAN CLASS="gutter"> 371:</SPAN><SPAN CLASS="syntax6">junit.setUp.descr</SPAN>=The JUnit setup method <SPAN CLASS="gutter"> 372:</SPAN> <SPAN CLASS="gutter"> 373:</SPAN><SPAN CLASS="syntax6">junit.test.descr</SPAN>=A unit test for JUnit <SPAN CLASS="gutter"> 374:</SPAN> <SPAN CLASS="gutterH"> 375:</SPAN><SPAN CLASS="syntax6">junit.tearDown.descr</SPAN>=The teardown method for JUnit <SPAN CLASS="gutter"> 376:</SPAN> <SPAN CLASS="gutter"> 377:</SPAN><SPAN CLASS="syntax6">junit.suite.descr</SPAN>=A unit test suite for JUnit <SPAN CLASS="gutter"> 378:</SPAN> <SPAN CLASS="gutter"> 379:</SPAN><SPAN CLASS="syntax6">junit.suite.return.descr</SPAN>=The test suite <SPAN CLASS="gutterH"> 380:</SPAN> <a name="tags"></a> <SPAN CLASS="gutter"> 381:</SPAN><SPAN CLASS="syntax1"># The following are the tags and the order</SPAN> <SPAN CLASS="gutter"> 382:</SPAN><SPAN CLASS="syntax1"># that are required in javadocs. If there is</SPAN> <SPAN CLASS="gutter"> 383:</SPAN><SPAN CLASS="syntax1"># description, then they are not required and the</SPAN> <SPAN CLASS="gutter"> 384:</SPAN><SPAN CLASS="syntax1"># system is only specifying the order in which they</SPAN> <SPAN CLASS="gutterH"> 385:</SPAN><SPAN CLASS="syntax1"># should appear. If a description is provided, then</SPAN> <SPAN CLASS="gutter"> 386:</SPAN><SPAN CLASS="syntax1"># the tag is required.</SPAN> <SPAN CLASS="gutter"> 387:</SPAN><SPAN CLASS="syntax6">author.descr</SPAN>=<SPAN CLASS="syntax8">{0}</SPAN> <SPAN CLASS="gutter"> 388:</SPAN> <SPAN CLASS="gutter"> 389:</SPAN><SPAN CLASS="syntax6">created.descr</SPAN>=<SPAN CLASS="syntax8">{1}</SPAN> <SPAN CLASS="gutterH"> 390:</SPAN> <SPAN CLASS="gutter"> 391:</SPAN><SPAN CLASS="syntax6">param.descr</SPAN>=Description of the Parameter <SPAN CLASS="gutter"> 392:</SPAN> <SPAN CLASS="gutter"> 393:</SPAN><SPAN CLASS="syntax6">return.descr</SPAN>=Description of the Return Value <SPAN CLASS="gutter"> 394:</SPAN> <SPAN CLASS="gutterH"> 395:</SPAN><SPAN CLASS="syntax6">exception.descr</SPAN>=Description of the Exception <SPAN CLASS="gutter"> 396:</SPAN> <SPAN CLASS="gutter"> 397:</SPAN><SPAN CLASS="syntax6">class.tags</SPAN>=author,created <SPAN CLASS="gutter"> 398:</SPAN><SPAN CLASS="syntax6">method.tags</SPAN>=param,return,exception <SPAN CLASS="gutter"> 399:</SPAN><SPAN CLASS="syntax6">field.tags</SPAN>= <SPAN CLASS="gutterH"> 400:</SPAN> <SPAN CLASS="gutter"> 401:</SPAN><SPAN CLASS="syntax1"># This feature describes what type of characters are used for</SPAN> <SPAN CLASS="gutter"> 402:</SPAN><SPAN CLASS="syntax1"># the java files.</SPAN> <SPAN CLASS="gutter"> 403:</SPAN><SPAN CLASS="syntax1"># * 1 - ASCII (1 byte characters)</SPAN> <SPAN CLASS="gutter"> 404:</SPAN><SPAN CLASS="syntax1"># * 2 - Unicode (2 byte characters - far east)</SPAN> <SPAN CLASS="gutterH"> 405:</SPAN><SPAN CLASS="syntax1"># * 3 - ASCII full (2 byte characters - far east)</SPAN> <SPAN CLASS="gutter"> 406:</SPAN><SPAN CLASS="syntax6">char.stream.type</SPAN>=<SPAN CLASS="syntax12">1</SPAN> <SPAN CLASS="gutter"> 407:</SPAN> <SPAN CLASS="gutter"> 408:</SPAN><SPAN CLASS="syntax1"># If you would like the pretty printer to make a backup</SPAN> <SPAN CLASS="gutter"> 409:</SPAN><SPAN CLASS="syntax1"># of the file before applying the pretty printer to the file,</SPAN> <SPAN CLASS="gutterH"> 410:</SPAN><SPAN CLASS="syntax1"># add an extension here.</SPAN> <SPAN CLASS="gutter"> 411:</SPAN><SPAN CLASS="syntax6">pretty.printer.backup.ext</SPAN>= <SPAN CLASS="gutter"> 412:</SPAN> <SPAN CLASS="gutter"> 413:</SPAN><SPAN CLASS="syntax1"># Insert the header</SPAN> <SPAN CLASS="gutter"> 414:</SPAN><SPAN CLASS="syntax1"># Add any amount of lines here, numbered sequentially.</SPAN> <SPAN CLASS="gutterH"> 415:</SPAN><SPAN CLASS="syntax6">header.1</SPAN>=/* <SPAN CLASS="gutter"> 416:</SPAN><SPAN CLASS="syntax6">header.2</SPAN>= * This is the header <SPAN CLASS="gutter"> 417:</SPAN><SPAN CLASS="syntax6">header.3</SPAN>= */ <SPAN CLASS="gutter"> 418:</SPAN> <SPAN CLASS="gutter"> 419:</SPAN><SPAN CLASS="syntax1"># Insert the footer</SPAN> <SPAN CLASS="gutterH"> 420:</SPAN><SPAN CLASS="syntax6">footer.1</SPAN>=/******** End of document *****/ <SPAN CLASS="gutter"> 421:</SPAN> <SPAN CLASS="gutter"> 422:</SPAN><SPAN CLASS="syntax1"># Should we sort the types and imports?</SPAN> <SPAN CLASS="gutter"> 423:</SPAN><SPAN CLASS="syntax6">sort.top</SPAN>=false <SPAN CLASS="gutter"> 424:</SPAN> <SPAN CLASS="gutterH"> 425:</SPAN><SPAN CLASS="syntax1"># List the prefixes of imports that should be</SPAN> <SPAN CLASS="gutter"> 426:</SPAN><SPAN CLASS="syntax1"># sorted to the top. For instance,</SPAN> <SPAN CLASS="gutter"> 427:</SPAN><SPAN CLASS="syntax1"># java,javax,org.w3c</SPAN> <SPAN CLASS="gutter"> 428:</SPAN><SPAN CLASS="syntax6">import.sort.important</SPAN>= <SPAN CLASS="gutter"> 429:</SPAN> <SPAN CLASS="gutterH"> 430:</SPAN><SPAN CLASS="syntax1"># If you want classes that are written by you to move to the end</SPAN> <SPAN CLASS="gutter"> 431:</SPAN><SPAN CLASS="syntax1"># of the list of imports change this value.</SPAN> <SPAN CLASS="gutter"> 432:</SPAN><SPAN CLASS="syntax1"># * 0 - Keep all the imports in alphabetical order</SPAN> <SPAN CLASS="gutter"> 433:</SPAN><SPAN CLASS="syntax1"># * 1 - If the package and the import start with the same value - com or org - put them at the end</SPAN> <SPAN CLASS="gutter"> 434:</SPAN><SPAN CLASS="syntax1"># * 2 - When package and import share 2 directory levels, the imports are listed last</SPAN> <SPAN CLASS="gutterH"> 435:</SPAN><SPAN CLASS="syntax1"># * 3 - When package and import share 3 directory levels, the imports are listed last</SPAN> <SPAN CLASS="gutter"> 436:</SPAN><SPAN CLASS="syntax6">import.sort.neighbourhood</SPAN>=<SPAN CLASS="syntax12">0</SPAN> <SPAN CLASS="gutter"> 437:</SPAN> <SPAN CLASS="gutter"> 438:</SPAN><SPAN CLASS="syntax1"># The following controls the order of methods, fields,</SPAN> <SPAN CLASS="gutter"> 439:</SPAN><SPAN CLASS="syntax1"># classes, etc inside a class.</SPAN> <SPAN CLASS="gutterH"> 440:</SPAN><SPAN CLASS="syntax1"># If you don't want to sort by any of these criterias, simply</SPAN> <SPAN CLASS="gutter"> 441:</SPAN><SPAN CLASS="syntax1"># comment them out, but make sure that the remaining</SPAN> <SPAN CLASS="gutter"> 442:</SPAN><SPAN CLASS="syntax1"># sort options are numbered sequentially.</SPAN> <SPAN CLASS="gutter"> 443:</SPAN> <SPAN CLASS="gutter"> 444:</SPAN><SPAN CLASS="syntax1"># This orders the items in the class by their type</SPAN> <SPAN CLASS="gutterH"> 445:</SPAN><SPAN CLASS="syntax1"># The items to order are fields, constructors, methods,</SPAN> <SPAN CLASS="gutter"> 446:</SPAN><SPAN CLASS="syntax1"># nested classes, nested interfaces, and initializers</SPAN> <SPAN CLASS="gutter"> 447:</SPAN><SPAN CLASS="syntax6">sort.1</SPAN>=Type(Field,Constructor,Method,NestedClass,NestedInterface,Initializer) <SPAN CLASS="gutter"> 448:</SPAN> <SPAN CLASS="gutter"> 449:</SPAN><SPAN CLASS="syntax1"># Order getters, setters, and other methods</SPAN> <SPAN CLASS="gutterH"> 450:</SPAN><SPAN CLASS="syntax1"># Setters are methods that start with the word 'set'</SPAN> <SPAN CLASS="gutter"> 451:</SPAN><SPAN CLASS="syntax1"># Getters are methods that start with the word 'get' or 'is'</SPAN> <SPAN CLASS="gutter"> 452:</SPAN><SPAN CLASS="syntax6">sort.2</SPAN>=Method(setter,getter,other) <SPAN CLASS="gutter"> 453:</SPAN> <SPAN CLASS="gutter"> 454:</SPAN><SPAN CLASS="syntax1"># How final methods and fields should be sorted</SPAN> <SPAN CLASS="gutterH"> 455:</SPAN><SPAN CLASS="syntax1"># * Final(top) - Move to the top</SPAN> <SPAN CLASS="gutter"> 456:</SPAN><SPAN CLASS="syntax1"># * Final(bottom) - Move to the bottom</SPAN> <SPAN CLASS="gutter"> 457:</SPAN><SPAN CLASS="syntax6">sort.3</SPAN>=Final(top) <SPAN CLASS="gutter"> 458:</SPAN> <SPAN CLASS="gutter"> 459:</SPAN><SPAN CLASS="syntax1"># How the protection should be used to sort fields and methods</SPAN> <SPAN CLASS="gutterH"> 460:</SPAN><SPAN CLASS="syntax1"># * Protection(public) - Move public to the top</SPAN> <SPAN CLASS="gutter"> 461:</SPAN><SPAN CLASS="syntax1"># * Protection(private) - Move private to the top</SPAN> <SPAN CLASS="gutter"> 462:</SPAN><SPAN CLASS="syntax6">sort.4</SPAN>=Protection(public) <SPAN CLASS="gutter"> 463:</SPAN> <SPAN CLASS="gutter"> 464:</SPAN><SPAN CLASS="syntax1"># How static methods and fields should be sorted</SPAN> <SPAN CLASS="gutterH"> 465:</SPAN><SPAN CLASS="syntax1"># * Class(Static,Instance) - Move static to the top</SPAN> <SPAN CLASS="gutter"> 466:</SPAN><SPAN CLASS="syntax1"># * Class(Instance,Static) - Move static to the bottom</SPAN> <SPAN CLASS="gutter"> 467:</SPAN><SPAN CLASS="syntax6">sort.5</SPAN>=Class(Static,Instance) <SPAN CLASS="gutter"> 468:</SPAN> <SPAN CLASS="gutter"> 469:</SPAN><SPAN CLASS="syntax1"># Order methods and fields in alphabetical order</SPAN> <SPAN CLASS="gutterH"> 470:</SPAN><SPAN CLASS="syntax6">sort.6</SPAN>=Alphabetical() <SPAN CLASS="gutter"> 471:</SPAN> <SPAN CLASS="gutter"> 472:</SPAN><SPAN CLASS="syntax1"># Maintain the order of fields with initializers</SPAN> <SPAN CLASS="gutter"> 473:</SPAN><SPAN CLASS="syntax6">sort.7</SPAN>=FieldInitializers() <SPAN CLASS="gutter"> 474:</SPAN> <SPAN CLASS="gutter"> 475:</SPAN> <SPAN CLASS="gutter"> 476:</SPAN><SPAN CLASS="syntax1"># *** JDK 1.5 *** Default description of the enumeration</SPAN> <SPAN CLASS="gutter"> 477:</SPAN><SPAN CLASS="syntax1"># see the <a href="#tags">tag description</a></SPAN> <SPAN CLASS="gutter"> 478:</SPAN><SPAN CLASS="syntax6">enum.descr</SPAN>=Description of Enumeration <SPAN CLASS="gutter"> 479:</SPAN> <SPAN CLASS="gutter"> 480:</SPAN> <SPAN CLASS="gutter"> 481:</SPAN><SPAN CLASS="syntax1"># *** JDK 1.5 *** Here is the order for tags for enumerations</SPAN> <SPAN CLASS="gutter"> 482:</SPAN><SPAN CLASS="syntax1"># see the <a href="#tags">tag description</a></SPAN> <SPAN CLASS="gutter"> 483:</SPAN><SPAN CLASS="syntax6">enum.tags</SPAN>=author <SPAN CLASS="gutter"> 484:</SPAN> <SPAN CLASS="gutter"> 485:</SPAN> <SPAN CLASS="gutter"> 486:</SPAN><SPAN CLASS="syntax1"># Should C Style comments that exist at the end of a line containing program</SPAN> <SPAN CLASS="gutter"> 487:</SPAN><SPAN CLASS="syntax1"># code be placed on that line or on its ownline.</SPAN> <SPAN CLASS="gutter"> 488:</SPAN><SPAN CLASS="syntax6">cstyle.comment.ownline</SPAN>=true <SPAN CLASS="gutter"> 489:</SPAN> </PRE></BODY> </HTML>