1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.base;
18
19 import static com.google.common.base.Preconditions.checkNotNull;
20
21 import com.google.common.annotations.Beta;
22 import com.google.common.annotations.GwtCompatible;
23
24 import java.io.IOException;
25 import java.util.AbstractList;
26 import java.util.Arrays;
27 import java.util.Iterator;
28 import java.util.Map;
29 import java.util.Map.Entry;
30
31 import javax.annotation.CheckReturnValue;
32 import javax.annotation.Nullable;
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 @GwtCompatible
66 public class Joiner {
67
68
69
70 public static Joiner on(String separator) {
71 return new Joiner(separator);
72 }
73
74
75
76
77 public static Joiner on(char separator) {
78 return new Joiner(String.valueOf(separator));
79 }
80
81 private final String separator;
82
83 private Joiner(String separator) {
84 this.separator = checkNotNull(separator);
85 }
86
87 private Joiner(Joiner prototype) {
88 this.separator = prototype.separator;
89 }
90
91
92
93
94
95 public <A extends Appendable> A appendTo(A appendable, Iterable<?> parts) throws IOException {
96 return appendTo(appendable, parts.iterator());
97 }
98
99
100
101
102
103
104
105 public <A extends Appendable> A appendTo(A appendable, Iterator<?> parts) throws IOException {
106 checkNotNull(appendable);
107 if (parts.hasNext()) {
108 appendable.append(toString(parts.next()));
109 while (parts.hasNext()) {
110 appendable.append(separator);
111 appendable.append(toString(parts.next()));
112 }
113 }
114 return appendable;
115 }
116
117
118
119
120
121 public final <A extends Appendable> A appendTo(A appendable, Object[] parts) throws IOException {
122 return appendTo(appendable, Arrays.asList(parts));
123 }
124
125
126
127
128 public final <A extends Appendable> A appendTo(
129 A appendable, @Nullable Object first, @Nullable Object second, Object... rest)
130 throws IOException {
131 return appendTo(appendable, iterable(first, second, rest));
132 }
133
134
135
136
137
138
139 public final StringBuilder appendTo(StringBuilder builder, Iterable<?> parts) {
140 return appendTo(builder, parts.iterator());
141 }
142
143
144
145
146
147
148
149
150 public final StringBuilder appendTo(StringBuilder builder, Iterator<?> parts) {
151 try {
152 appendTo((Appendable) builder, parts);
153 } catch (IOException impossible) {
154 throw new AssertionError(impossible);
155 }
156 return builder;
157 }
158
159
160
161
162
163
164 public final StringBuilder appendTo(StringBuilder builder, Object[] parts) {
165 return appendTo(builder, Arrays.asList(parts));
166 }
167
168
169
170
171
172
173 public final StringBuilder appendTo(
174 StringBuilder builder, @Nullable Object first, @Nullable Object second, Object... rest) {
175 return appendTo(builder, iterable(first, second, rest));
176 }
177
178
179
180
181
182 public final String join(Iterable<?> parts) {
183 return join(parts.iterator());
184 }
185
186
187
188
189
190
191
192 public final String join(Iterator<?> parts) {
193 return appendTo(new StringBuilder(), parts).toString();
194 }
195
196
197
198
199
200 public final String join(Object[] parts) {
201 return join(Arrays.asList(parts));
202 }
203
204
205
206
207
208 public final String join(@Nullable Object first, @Nullable Object second, Object... rest) {
209 return join(iterable(first, second, rest));
210 }
211
212
213
214
215
216 @CheckReturnValue
217 public Joiner useForNull(final String nullText) {
218 checkNotNull(nullText);
219 return new Joiner(this) {
220 @Override CharSequence toString(@Nullable Object part) {
221 return (part == null) ? nullText : Joiner.this.toString(part);
222 }
223
224 @Override public Joiner useForNull(String nullText) {
225 throw new UnsupportedOperationException("already specified useForNull");
226 }
227
228 @Override public Joiner skipNulls() {
229 throw new UnsupportedOperationException("already specified useForNull");
230 }
231 };
232 }
233
234
235
236
237
238 @CheckReturnValue
239 public Joiner skipNulls() {
240 return new Joiner(this) {
241 @Override public <A extends Appendable> A appendTo(A appendable, Iterator<?> parts)
242 throws IOException {
243 checkNotNull(appendable, "appendable");
244 checkNotNull(parts, "parts");
245 while (parts.hasNext()) {
246 Object part = parts.next();
247 if (part != null) {
248 appendable.append(Joiner.this.toString(part));
249 break;
250 }
251 }
252 while (parts.hasNext()) {
253 Object part = parts.next();
254 if (part != null) {
255 appendable.append(separator);
256 appendable.append(Joiner.this.toString(part));
257 }
258 }
259 return appendable;
260 }
261
262 @Override public Joiner useForNull(String nullText) {
263 throw new UnsupportedOperationException("already specified skipNulls");
264 }
265
266 @Override public MapJoiner withKeyValueSeparator(String kvs) {
267 throw new UnsupportedOperationException("can't use .skipNulls() with maps");
268 }
269 };
270 }
271
272
273
274
275
276 @CheckReturnValue
277 public MapJoiner withKeyValueSeparator(String keyValueSeparator) {
278 return new MapJoiner(this, keyValueSeparator);
279 }
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299 public static final class MapJoiner {
300 private final Joiner joiner;
301 private final String keyValueSeparator;
302
303 private MapJoiner(Joiner joiner, String keyValueSeparator) {
304 this.joiner = joiner;
305 this.keyValueSeparator = checkNotNull(keyValueSeparator);
306 }
307
308
309
310
311
312 public <A extends Appendable> A appendTo(A appendable, Map<?, ?> map) throws IOException {
313 return appendTo(appendable, map.entrySet());
314 }
315
316
317
318
319
320
321 public StringBuilder appendTo(StringBuilder builder, Map<?, ?> map) {
322 return appendTo(builder, map.entrySet());
323 }
324
325
326
327
328
329 public String join(Map<?, ?> map) {
330 return join(map.entrySet());
331 }
332
333
334
335
336
337
338
339 @Beta
340 public <A extends Appendable> A appendTo(A appendable, Iterable<? extends Entry<?, ?>> entries)
341 throws IOException {
342 return appendTo(appendable, entries.iterator());
343 }
344
345
346
347
348
349
350
351 @Beta
352 public <A extends Appendable> A appendTo(A appendable, Iterator<? extends Entry<?, ?>> parts)
353 throws IOException {
354 checkNotNull(appendable);
355 if (parts.hasNext()) {
356 Entry<?, ?> entry = parts.next();
357 appendable.append(joiner.toString(entry.getKey()));
358 appendable.append(keyValueSeparator);
359 appendable.append(joiner.toString(entry.getValue()));
360 while (parts.hasNext()) {
361 appendable.append(joiner.separator);
362 Entry<?, ?> e = parts.next();
363 appendable.append(joiner.toString(e.getKey()));
364 appendable.append(keyValueSeparator);
365 appendable.append(joiner.toString(e.getValue()));
366 }
367 }
368 return appendable;
369 }
370
371
372
373
374
375
376
377
378 @Beta
379 public StringBuilder appendTo(StringBuilder builder, Iterable<? extends Entry<?, ?>> entries) {
380 return appendTo(builder, entries.iterator());
381 }
382
383
384
385
386
387
388
389
390 @Beta
391 public StringBuilder appendTo(StringBuilder builder, Iterator<? extends Entry<?, ?>> entries) {
392 try {
393 appendTo((Appendable) builder, entries);
394 } catch (IOException impossible) {
395 throw new AssertionError(impossible);
396 }
397 return builder;
398 }
399
400
401
402
403
404
405
406 @Beta
407 public String join(Iterable<? extends Entry<?, ?>> entries) {
408 return join(entries.iterator());
409 }
410
411
412
413
414
415
416
417 @Beta
418 public String join(Iterator<? extends Entry<?, ?>> entries) {
419 return appendTo(new StringBuilder(), entries).toString();
420 }
421
422
423
424
425
426 @CheckReturnValue
427 public MapJoiner useForNull(String nullText) {
428 return new MapJoiner(joiner.useForNull(nullText), keyValueSeparator);
429 }
430 }
431
432 CharSequence toString(Object part) {
433 checkNotNull(part);
434 return (part instanceof CharSequence) ? (CharSequence) part : part.toString();
435 }
436
437 private static Iterable<Object> iterable(
438 final Object first, final Object second, final Object[] rest) {
439 checkNotNull(rest);
440 return new AbstractList<Object>() {
441 @Override public int size() {
442 return rest.length + 2;
443 }
444
445 @Override public Object get(int index) {
446 switch (index) {
447 case 0:
448 return first;
449 case 1:
450 return second;
451 default:
452 return rest[index - 2];
453 }
454 }
455 };
456 }
457 }