Android_Utils/CheckUtils.java at master · RealMoMo/Android_Utils · GitHub

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
packagecom.realmo.utils;


publicfinalclassCheckUtils {

privateCheckUtils() {
thrownewIllegalStateException("you can't instantiate me!");
 }

publicstaticvoidcheckArgument(booleanexpression) {
if (!expression) {
thrownewIllegalArgumentException();
 }
 }

publicstaticvoidcheckArgument(booleanexpression, ObjecterrorMessage) {
if (!expression) {
thrownewIllegalArgumentException(String.valueOf(errorMessage));
 }
 }

publicstaticvoidcheckArgument(booleanexpression, StringerrorMessageTemplate, Object... errorMessageArgs) {
if (!expression) {
thrownewIllegalArgumentException(format(errorMessageTemplate, errorMessageArgs));
 }
 }

publicstaticvoidcheckState(booleanexpression) {
if (!expression) {
thrownewIllegalStateException();
 }
 }

publicstaticvoidcheckState(booleanexpression, ObjecterrorMessage) {
if (!expression) {
thrownewIllegalStateException(String.valueOf(errorMessage));
 }
 }

publicstaticvoidcheckState(booleanexpression, StringerrorMessageTemplate, Object... errorMessageArgs) {
if (!expression) {
thrownewIllegalStateException(format(errorMessageTemplate, errorMessageArgs));
 }
 }

publicstatic <T> TcheckNotNull(Treference) {
if (reference == null) {
thrownewNullPointerException();
 } else {
returnreference;
 }
 }

publicstatic <T> TcheckNotNull(Treference, ObjecterrorMessage) {
if (reference == null) {
thrownewNullPointerException(String.valueOf(errorMessage));
 } else {
returnreference;
 }
 }

publicstatic <T> TcheckNotNull(Treference, StringerrorMessageTemplate, Object... errorMessageArgs) {
if (reference == null) {
thrownewNullPointerException(format(errorMessageTemplate, errorMessageArgs));
 } else {
returnreference;
 }
 }

publicstaticintcheckElementIndex(intindex, intsize) {
returncheckElementIndex(index, size, "index");
 }

publicstaticintcheckElementIndex(intindex, intsize, Stringdesc) {
if (index >= 0 && index < size) {
returnindex;
 } else {
thrownewIndexOutOfBoundsException(badElementIndex(index, size, desc));
 }
 }

privatestaticStringbadElementIndex(intindex, intsize, Stringdesc) {
if (index < 0) {
returnformat("%s (%s) must not be negative", newObject[]{desc, Integer.valueOf(index)});
 } elseif (size < 0) {
thrownewIllegalArgumentException((newStringBuilder(26)).append("negative size: ").append(size).toString());
 } else {
returnformat("%s (%s) must be less than size (%s)", newObject[]{desc, Integer.valueOf(index), Integer.valueOf(size)});
 }
 }

publicstaticintcheckPositionIndex(intindex, intsize) {
returncheckPositionIndex(index, size, "index");
 }

publicstaticintcheckPositionIndex(intindex, intsize, Stringdesc) {
if (index >= 0 && index <= size) {
returnindex;
 } else {
thrownewIndexOutOfBoundsException(badPositionIndex(index, size, desc));
 }
 }

privatestaticStringbadPositionIndex(intindex, intsize, Stringdesc) {
if (index < 0) {
returnformat("%s (%s) must not be negative", newObject[]{desc, Integer.valueOf(index)});
 } elseif (size < 0) {
thrownewIllegalArgumentException((newStringBuilder(26)).append("negative size: ").append(size).toString());
 } else {
returnformat("%s (%s) must not be greater than size (%s)", newObject[]{desc, Integer.valueOf(index), Integer.valueOf(size)});
 }
 }

publicstaticvoidcheckPositionIndexes(intstart, intend, intsize) {
if (start < 0 || end < start || end > size) {
thrownewIndexOutOfBoundsException(badPositionIndexes(start, end, size));
 }
 }

privatestaticStringbadPositionIndexes(intstart, intend, intsize) {
returnstart >= 0 && start <= size ? (end >= 0 && end <= size ? format("end index (%s) must not be less than start index (%s)", newObject[]{Integer.valueOf(end), Integer.valueOf(start)}) : badPositionIndex(end, size, "end index")) : badPositionIndex(start, size, "start index");
 }

staticStringformat(Stringtemplate, Object... args) {
template = String.valueOf(template);
StringBuilderbuilder = newStringBuilder(template.length() + 16 * args.length);
inttemplateStart = 0;

inti;
intplaceholderStart;
for (i = 0; i < args.length; templateStart = placeholderStart + 2) {
placeholderStart = template.indexOf("%s", templateStart);
if (placeholderStart == -1) {
break;
 }

builder.append(template.substring(templateStart, placeholderStart));
builder.append(args[i++]);
 }

builder.append(template.substring(templateStart));
if (i < args.length) {
builder.append(" [");
builder.append(args[i++]);

while (i < args.length) {
builder.append(", ");
builder.append(args[i++]);
 }

builder.append(']');
 }

returnbuilder.toString();
 }
}