1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109 | package Torello.Java;
import Torello.Java.StringParse;
import Torello.Java.Verbosity;
import static Torello.Java.C.BYELLOW;
import static Torello.Java.C.BCYAN;
import static Torello.Java.C.RESET;
import java.io.IOException;
class PrintingRecSingleLine
{
// Re-Use the Pointer, I guess
private static final String I4 = Helper.I4;
// This is the only file/class that even has an "I8"
private static final String I8 = I4 + I4;
String originalLine, newLine;
int originalLineLength, newLineLength, lineNumber;
void saveOriginalLine (String s) { this.originalLine = s; }
void saveNewLine (String s) { this.newLine = s; }
void saveOriginalLineLength (int i) { this.originalLineLength = i; }
void saveNewLineLength (int i) { this.newLineLength = i; }
void saveLineNumber (int i) { this.lineNumber = i; }
String toString(
final int maxLineLen,
final boolean useUNIXColors
)
{
// The line-number (as an integer), converted to to a line-number as a string
final String origLineLenStr = "" + originalLineLength;
final String newLineLenStr = "" + newLineLength;
// This is nothing more than the amount of space-characters need for the output
// to be evenly-spaced / lined-up. Since (at least in my code), line-numbers are
// always less than 100, or equal to exactly 100 characters, most of the time
// 'oPad' and 'nPad' will be zero-length / empty String's!
//
// In the '.java' Files I wite, they will be a 1-character long String that simply
// contains 1 Space-Character.
final String oPad = StringParse.nChars(' ', maxLineLen - origLineLenStr.length());
final String nPad = StringParse.nChars(' ', maxLineLen - newLineLenStr.length());
if (useUNIXColors) return
I4 + "LINE: " + BYELLOW + "" + lineNumber + RESET + '\n' +
I8 + "[" + BCYAN + origLineLenStr + RESET + "]: " + oPad + originalLine + '\n' +
I8 + '[' + BCYAN + newLineLenStr + RESET + "]: " + nPad + newLine + '\n' +
'\n';
else return
I4 + "LINE: " + "" + lineNumber + '\n' +
I8 + "[" + origLineLenStr + "]: " + oPad + originalLine + '\n' +
I8 + '[' + newLineLenStr + "]: " + nPad + newLine + '\n' +
'\n';
}
static void printAll(
final PrintingRecSingleLine[] recs,
final boolean useUNIXColors,
final Appendable appendable,
final Verbosity verbosity
)
// This method cannot actually throw IOException. The user's Appendable is not always
// present. If it is, and it is used, it will be wrapped in an AppendableSafe
// instance. If the User-Appendable is not present, System.out is the only thing being
// written to, and that never throws IOException.
throws IOException
{
// '.....' is printed when the user requests Verbosity.Quiet mode. Therefore in this
// particular case, it is necessary to print a newline character.
if (verbosity == Verbosity.Quiet) appendable.append('\n');
// The longest line-length for all lines that had matches which must be changed
int max = 0;
for (PrintingRecSingleLine r : recs)
{
if (r.originalLineLength > max) max = r.originalLineLength;
if (r.newLineLength > max) max = r.newLineLength;
}
// It is (a lot) more efficient to do this with a divide-by-10-loop, but I'm leaving
// the Math.log10 call / invocation, because I don't care.
//
// Variable 'l' is the Maximum-Length of the Line-Length-As-A-String. Note that is not
// the same as the "Maximum-Line-Length". So if the Maximum-Line-Length were '99', the
// Max-Line-Len-As-A-String is '2' because only two characters are required to print
// the number 99.
//
// I choose to call this concept 'l'
final int l = 1 + ((int) Math.floor(Math.log10(max)));
for (PrintingRecSingleLine r : recs)
appendable.append(r.toString(l, useUNIXColors));
}
}
|