1 package org.apache.maven.plugins.assembly.io;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.io.PrintWriter;
23 import java.io.StringWriter;
24 import java.util.ArrayList;
25 import java.util.Iterator;
26 import java.util.List;
27
28
29
30
31
32 class DefaultMessageHolder
33 implements MessageHolder
34 {
35
36 private List<Message> messages = new ArrayList<Message>();
37
38 private Message currentMessage;
39
40 private int defaultMessageLevel = MessageLevels.LEVEL_INFO;
41
42 private boolean[] messageLevelStates;
43
44 private MessageSink onDemandSink;
45
46
47
48
49 DefaultMessageHolder()
50 {
51 this.messageLevelStates = MessageLevels.getLevelStates( MessageLevels.LEVEL_INFO );
52 }
53
54
55 public MessageHolder addMessage( CharSequence messagePart, Throwable error )
56 {
57 return addMessage( defaultMessageLevel, messagePart, error );
58 }
59
60
61
62
63
64
65
66 MessageHolder addMessage( int level, CharSequence messagePart, Throwable error )
67 {
68 newMessage( level );
69 append( messagePart.toString() );
70 append( error );
71
72 return this;
73 }
74
75
76 public MessageHolder addMessage( CharSequence messagePart )
77 {
78 return addMessage( defaultMessageLevel, messagePart );
79 }
80
81
82
83
84
85
86 protected MessageHolder addMessage( int level, CharSequence messagePart )
87 {
88 newMessage( level );
89 append( messagePart.toString() );
90
91 return this;
92 }
93
94
95 public MessageHolder addMessage( Throwable error )
96 {
97 return addMessage( defaultMessageLevel, error );
98 }
99
100
101
102
103
104
105 protected MessageHolder addMessage( int level, Throwable error )
106 {
107 newMessage( level );
108 append( error );
109
110 return this;
111 }
112
113
114 public MessageHolder append( CharSequence messagePart )
115 {
116 if ( currentMessage == null )
117 {
118 newMessage();
119 }
120
121 currentMessage.append( messagePart.toString() );
122
123 return this;
124 }
125
126
127 public MessageHolder append( Throwable error )
128 {
129 if ( currentMessage == null )
130 {
131 newMessage();
132 }
133
134 currentMessage.setError( error );
135
136 return this;
137 }
138
139
140 public boolean isEmpty()
141 {
142 return messages.isEmpty();
143 }
144
145
146 public MessageHolder newMessage()
147 {
148 newMessage( defaultMessageLevel );
149
150 return this;
151 }
152
153
154
155
156 protected void newMessage( int messageLevel )
157 {
158 if ( onDemandSink != null && currentMessage != null )
159 {
160 renderTo( currentMessage, onDemandSink );
161 }
162
163 currentMessage = new Message( messageLevel, onDemandSink );
164 messages.add( currentMessage );
165 }
166
167
168 public String render()
169 {
170 StringBuffer buffer = new StringBuffer();
171
172 int counter = 1;
173 for ( Iterator<Message> it = messages.iterator(); it.hasNext(); )
174 {
175 Message message = (Message) it.next();
176
177 int ml = message.getMessageLevel();
178
179 if ( ml >= messageLevelStates.length || ml < 0 )
180 {
181 ml = MessageLevels.LEVEL_DEBUG;
182 }
183
184 if ( !messageLevelStates[ml] )
185 {
186 continue;
187 }
188
189 CharSequence content = message.render();
190 String label = MessageLevels.getLevelLabel( message.getMessageLevel() );
191
192 if ( content.length() > label.length() + 3 )
193 {
194 buffer.append( '[' ).append( counter++ ).append( "] " );
195 buffer.append( content.toString() );
196
197 if ( it.hasNext() )
198 {
199 buffer.append( "\n\n" );
200 }
201 }
202 }
203
204 return buffer.toString();
205 }
206
207
208 public int size()
209 {
210 return messages.size();
211 }
212
213 private static final class Message
214 {
215 private StringBuffer message = new StringBuffer();
216
217 private Throwable error;
218
219 private final int messageLevel;
220
221 private final MessageSink onDemandSink;
222
223 Message( int messageLevel, MessageSink onDemandSink )
224 {
225 this.messageLevel = messageLevel;
226
227 this.onDemandSink = onDemandSink;
228 }
229
230 public Message setError( Throwable pError )
231 {
232 this.error = pError;
233 return this;
234 }
235
236 public Message append( CharSequence pMessage )
237 {
238 this.message.append( pMessage.toString() );
239 return this;
240 }
241
242
243
244
245 public int getMessageLevel()
246 {
247 return messageLevel;
248 }
249
250
251
252
253 public CharSequence render()
254 {
255 StringBuffer buffer = new StringBuffer();
256
257 if ( onDemandSink == null )
258 {
259 buffer.append( '[' ).append( MessageLevels.getLevelLabel( messageLevel ) ).append( "] " );
260 }
261 if ( message != null && message.length() > 0 )
262 {
263 buffer.append( message );
264
265 if ( error != null )
266 {
267 buffer.append( '\n' );
268 }
269 }
270
271 if ( error != null )
272 {
273 buffer.append( "Error:\n" );
274
275 StringWriter sw = new StringWriter();
276 PrintWriter pw = new PrintWriter( sw );
277 error.printStackTrace( pw );
278
279 buffer.append( sw.toString() );
280 }
281
282 return buffer;
283 }
284 }
285
286
287 public MessageHolder addDebugMessage( CharSequence messagePart, Throwable error )
288 {
289 return addMessage( MessageLevels.LEVEL_DEBUG, messagePart, error );
290 }
291
292
293 public MessageHolder addDebugMessage( CharSequence messagePart )
294 {
295 return addMessage( MessageLevels.LEVEL_DEBUG, messagePart );
296 }
297
298
299 public MessageHolder addDebugMessage( Throwable error )
300 {
301 return addMessage( MessageLevels.LEVEL_DEBUG, error );
302 }
303
304
305 public MessageHolder addErrorMessage( CharSequence messagePart, Throwable error )
306 {
307 return addMessage( MessageLevels.LEVEL_ERROR, messagePart, error );
308 }
309
310
311 public MessageHolder addErrorMessage( CharSequence messagePart )
312 {
313 return addMessage( MessageLevels.LEVEL_ERROR, messagePart );
314 }
315
316
317 public MessageHolder addErrorMessage( Throwable error )
318 {
319 return addMessage( MessageLevels.LEVEL_ERROR, error );
320 }
321
322
323 public MessageHolder addInfoMessage( CharSequence messagePart, Throwable error )
324 {
325 return addMessage( MessageLevels.LEVEL_INFO, messagePart, error );
326 }
327
328
329 public MessageHolder addInfoMessage( CharSequence messagePart )
330 {
331 return addMessage( MessageLevels.LEVEL_INFO, messagePart );
332 }
333
334
335 public MessageHolder addInfoMessage( Throwable error )
336 {
337 return addMessage( MessageLevels.LEVEL_INFO, error );
338 }
339
340
341 public MessageHolder addSevereMessage( CharSequence messagePart, Throwable error )
342 {
343 return addMessage( MessageLevels.LEVEL_SEVERE, messagePart, error );
344 }
345
346
347 public MessageHolder addSevereMessage( CharSequence messagePart )
348 {
349 return addMessage( MessageLevels.LEVEL_SEVERE, messagePart );
350 }
351
352
353 public MessageHolder addSevereMessage( Throwable error )
354 {
355 return addMessage( MessageLevels.LEVEL_SEVERE, error );
356 }
357
358
359 public MessageHolder addWarningMessage( CharSequence messagePart, Throwable error )
360 {
361 return addMessage( MessageLevels.LEVEL_WARNING, messagePart, error );
362 }
363
364
365 public MessageHolder addWarningMessage( CharSequence messagePart )
366 {
367 return addMessage( MessageLevels.LEVEL_WARNING, messagePart );
368 }
369
370
371 public MessageHolder addWarningMessage( Throwable error )
372 {
373 return addMessage( MessageLevels.LEVEL_WARNING, error );
374 }
375
376
377 public int countDebugMessages()
378 {
379 return countMessagesOfType( MessageLevels.LEVEL_DEBUG );
380 }
381
382
383 public int countErrorMessages()
384 {
385 return countMessagesOfType( MessageLevels.LEVEL_ERROR );
386 }
387
388
389 public int countInfoMessages()
390 {
391 return countMessagesOfType( MessageLevels.LEVEL_INFO );
392 }
393
394
395 public int countMessages()
396 {
397 return size();
398 }
399
400
401 public int countSevereMessages()
402 {
403 return countMessagesOfType( MessageLevels.LEVEL_SEVERE );
404 }
405
406
407 public int countWarningMessages()
408 {
409 return countMessagesOfType( MessageLevels.LEVEL_WARNING );
410 }
411
412
413
414
415
416 private int countMessagesOfType( int messageLevel )
417 {
418 int count = 0;
419
420 for ( Message message : messages )
421 {
422 if ( messageLevel == message.getMessageLevel() )
423 {
424 count++;
425 }
426 }
427
428 return count;
429 }
430
431
432 public boolean isDebugEnabled()
433 {
434 return messageLevelStates[MessageLevels.LEVEL_DEBUG];
435 }
436
437
438 public boolean isErrorEnabled()
439 {
440 return messageLevelStates[MessageLevels.LEVEL_ERROR];
441 }
442
443
444 public boolean isInfoEnabled()
445 {
446 return messageLevelStates[MessageLevels.LEVEL_INFO];
447 }
448
449
450 public boolean isSevereEnabled()
451 {
452 return messageLevelStates[MessageLevels.LEVEL_SEVERE];
453 }
454
455
456 public boolean isWarningEnabled()
457 {
458 return messageLevelStates[MessageLevels.LEVEL_WARNING];
459 }
460
461
462 public MessageHolder newDebugMessage()
463 {
464 if ( isDebugEnabled() )
465 {
466 newMessage( MessageLevels.LEVEL_DEBUG );
467 }
468
469 return this;
470 }
471
472
473 public MessageHolder newErrorMessage()
474 {
475 if ( isErrorEnabled() )
476 {
477 newMessage( MessageLevels.LEVEL_ERROR );
478 }
479
480 return this;
481 }
482
483
484 public MessageHolder newInfoMessage()
485 {
486 if ( isInfoEnabled() )
487 {
488 newMessage( MessageLevels.LEVEL_INFO );
489 }
490
491 return this;
492 }
493
494
495 public MessageHolder newSevereMessage()
496 {
497 if ( isSevereEnabled() )
498 {
499 newMessage( MessageLevels.LEVEL_SEVERE );
500 }
501
502 return this;
503 }
504
505
506 public MessageHolder newWarningMessage()
507 {
508 if ( isWarningEnabled() )
509 {
510 newMessage( MessageLevels.LEVEL_WARNING );
511 }
512
513 return this;
514 }
515
516
517 public void setDebugEnabled( boolean enabled )
518 {
519 messageLevelStates[MessageLevels.LEVEL_DEBUG] = enabled;
520 }
521
522
523 public void setErrorEnabled( boolean enabled )
524 {
525 messageLevelStates[MessageLevels.LEVEL_ERROR] = enabled;
526 }
527
528
529 public void setInfoEnabled( boolean enabled )
530 {
531 messageLevelStates[MessageLevels.LEVEL_INFO] = enabled;
532 }
533
534
535 public void setSevereEnabled( boolean enabled )
536 {
537 messageLevelStates[MessageLevels.LEVEL_SEVERE] = enabled;
538 }
539
540
541 public void setWarningEnabled( boolean enabled )
542 {
543 messageLevelStates[MessageLevels.LEVEL_WARNING] = enabled;
544 }
545
546
547 public void flush()
548 {
549 if ( onDemandSink != null && currentMessage != null )
550 {
551 renderTo( currentMessage, onDemandSink );
552 currentMessage = null;
553 }
554 }
555
556
557 public void render( MessageSink sink )
558 {
559 for ( Message message : messages )
560 {
561 renderTo( message, sink );
562 }
563 }
564
565
566
567
568
569 protected void renderTo( Message message, MessageSink sink )
570 {
571 switch ( message.getMessageLevel() )
572 {
573 case ( MessageLevels.LEVEL_SEVERE ):
574 sink.severe( message.render().toString() );
575 break;
576
577 case ( MessageLevels.LEVEL_ERROR ):
578 sink.error( message.render().toString() );
579 break;
580
581 case ( MessageLevels.LEVEL_WARNING ):
582 sink.warning( message.render().toString() );
583 break;
584
585 case ( MessageLevels.LEVEL_INFO ):
586 sink.info( message.render().toString() );
587 break;
588
589 default:
590 sink.debug( message.render().toString() );
591 }
592 }
593
594 }