Sophie: jrefactory-0:2.8.9-4.2mdv2007.0 i586

jrefactory-2.8.9-4.2mdv2007.0.i586.rpm

<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>