View Javadoc
1   package org.apache.maven.plugins.assembly.io;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
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   * Default Message Holder.
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       * Create instance.
48       */
49      DefaultMessageHolder()
50      {
51          this.messageLevelStates = MessageLevels.getLevelStates( MessageLevels.LEVEL_INFO );
52      }
53  
54      /** {@inheritDoc} */
55      public MessageHolder addMessage( CharSequence messagePart, Throwable error )
56      {
57          return addMessage( defaultMessageLevel, messagePart, error );
58      }
59  
60      /**
61       * @param level Level.
62       * @param messagePart Message part.
63       * @param error {@link Throwable}
64       * @return {@link MessageHolder}
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      /** {@inheritDoc} */
76      public MessageHolder addMessage( CharSequence messagePart )
77      {
78          return addMessage( defaultMessageLevel, messagePart );
79      }
80  
81      /**
82       * @param level level.
83       * @param messagePart message part.
84       * @return {@link MessageHolder}
85       */
86      protected MessageHolder addMessage( int level, CharSequence messagePart )
87      {
88          newMessage( level );
89          append( messagePart.toString() );
90  
91          return this;
92      }
93  
94      /** {@inheritDoc} */
95      public MessageHolder addMessage( Throwable error )
96      {
97          return addMessage( defaultMessageLevel, error );
98      }
99  
100     /**
101      * @param level level.
102      * @param error {@link Throwable}
103      * @return {@link MessageHolder}
104      */
105     protected MessageHolder addMessage( int level, Throwable error )
106     {
107         newMessage( level );
108         append( error );
109 
110         return this;
111     }
112 
113     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
140     public boolean isEmpty()
141     {
142         return messages.isEmpty();
143     }
144 
145     /** {@inheritDoc} */
146     public MessageHolder newMessage()
147     {
148         newMessage( defaultMessageLevel );
149 
150         return this;
151     }
152 
153     /**
154      * @param messageLevel message level.
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     /** {@inheritDoc} */
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     /** {@inheritDoc} */
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          * @return message level.
244          */
245         public int getMessageLevel()
246         {
247             return messageLevel;
248         }
249 
250         /**
251          * @return Sequence.
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     /** {@inheritDoc} */
287     public MessageHolder addDebugMessage( CharSequence messagePart, Throwable error )
288     {
289         return addMessage( MessageLevels.LEVEL_DEBUG, messagePart, error );
290     }
291 
292     /** {@inheritDoc} */
293     public MessageHolder addDebugMessage( CharSequence messagePart )
294     {
295         return addMessage( MessageLevels.LEVEL_DEBUG, messagePart );
296     }
297 
298     /** {@inheritDoc} */
299     public MessageHolder addDebugMessage( Throwable error )
300     {
301         return addMessage( MessageLevels.LEVEL_DEBUG, error );
302     }
303 
304     /** {@inheritDoc} */
305     public MessageHolder addErrorMessage( CharSequence messagePart, Throwable error )
306     {
307         return addMessage( MessageLevels.LEVEL_ERROR, messagePart, error );
308     }
309 
310     /** {@inheritDoc} */
311     public MessageHolder addErrorMessage( CharSequence messagePart )
312     {
313         return addMessage( MessageLevels.LEVEL_ERROR, messagePart );
314     }
315 
316     /** {@inheritDoc} */
317     public MessageHolder addErrorMessage( Throwable error )
318     {
319         return addMessage( MessageLevels.LEVEL_ERROR, error );
320     }
321 
322     /** {@inheritDoc} */
323     public MessageHolder addInfoMessage( CharSequence messagePart, Throwable error )
324     {
325         return addMessage( MessageLevels.LEVEL_INFO, messagePart, error );
326     }
327 
328     /** {@inheritDoc} */
329     public MessageHolder addInfoMessage( CharSequence messagePart )
330     {
331         return addMessage( MessageLevels.LEVEL_INFO, messagePart );
332     }
333 
334     /** {@inheritDoc} */
335     public MessageHolder addInfoMessage( Throwable error )
336     {
337         return addMessage( MessageLevels.LEVEL_INFO, error );
338     }
339 
340     /** {@inheritDoc} */
341     public MessageHolder addSevereMessage( CharSequence messagePart, Throwable error )
342     {
343         return addMessage( MessageLevels.LEVEL_SEVERE, messagePart, error );
344     }
345 
346     /** {@inheritDoc} */
347     public MessageHolder addSevereMessage( CharSequence messagePart )
348     {
349         return addMessage( MessageLevels.LEVEL_SEVERE, messagePart );
350     }
351 
352     /** {@inheritDoc} */
353     public MessageHolder addSevereMessage( Throwable error )
354     {
355         return addMessage( MessageLevels.LEVEL_SEVERE, error );
356     }
357 
358     /** {@inheritDoc} */
359     public MessageHolder addWarningMessage( CharSequence messagePart, Throwable error )
360     {
361         return addMessage( MessageLevels.LEVEL_WARNING, messagePart, error );
362     }
363 
364     /** {@inheritDoc} */
365     public MessageHolder addWarningMessage( CharSequence messagePart )
366     {
367         return addMessage( MessageLevels.LEVEL_WARNING, messagePart );
368     }
369 
370     /** {@inheritDoc} */
371     public MessageHolder addWarningMessage( Throwable error )
372     {
373         return addMessage( MessageLevels.LEVEL_WARNING, error );
374     }
375 
376     /** {@inheritDoc} */
377     public int countDebugMessages()
378     {
379         return countMessagesOfType( MessageLevels.LEVEL_DEBUG );
380     }
381 
382     /** {@inheritDoc} */
383     public int countErrorMessages()
384     {
385         return countMessagesOfType( MessageLevels.LEVEL_ERROR );
386     }
387 
388     /** {@inheritDoc} */
389     public int countInfoMessages()
390     {
391         return countMessagesOfType( MessageLevels.LEVEL_INFO );
392     }
393 
394     /** {@inheritDoc} */
395     public int countMessages()
396     {
397         return size();
398     }
399 
400     /** {@inheritDoc} */
401     public int countSevereMessages()
402     {
403         return countMessagesOfType( MessageLevels.LEVEL_SEVERE );
404     }
405 
406     /** {@inheritDoc} */
407     public int countWarningMessages()
408     {
409         return countMessagesOfType( MessageLevels.LEVEL_WARNING );
410     }
411 
412     /**
413      * @param messageLevel leve.
414      * @return number of messages.
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     /** {@inheritDoc} */
432     public boolean isDebugEnabled()
433     {
434         return messageLevelStates[MessageLevels.LEVEL_DEBUG];
435     }
436 
437     /** {@inheritDoc} */
438     public boolean isErrorEnabled()
439     {
440         return messageLevelStates[MessageLevels.LEVEL_ERROR];
441     }
442 
443     /** {@inheritDoc} */
444     public boolean isInfoEnabled()
445     {
446         return messageLevelStates[MessageLevels.LEVEL_INFO];
447     }
448 
449     /** {@inheritDoc} */
450     public boolean isSevereEnabled()
451     {
452         return messageLevelStates[MessageLevels.LEVEL_SEVERE];
453     }
454 
455     /** {@inheritDoc} */
456     public boolean isWarningEnabled()
457     {
458         return messageLevelStates[MessageLevels.LEVEL_WARNING];
459     }
460 
461     /** {@inheritDoc} */
462     public MessageHolder newDebugMessage()
463     {
464         if ( isDebugEnabled() )
465         {
466             newMessage( MessageLevels.LEVEL_DEBUG );
467         }
468 
469         return this;
470     }
471 
472     /** {@inheritDoc} */
473     public MessageHolder newErrorMessage()
474     {
475         if ( isErrorEnabled() )
476         {
477             newMessage( MessageLevels.LEVEL_ERROR );
478         }
479 
480         return this;
481     }
482 
483     /** {@inheritDoc} */
484     public MessageHolder newInfoMessage()
485     {
486         if ( isInfoEnabled() )
487         {
488             newMessage( MessageLevels.LEVEL_INFO );
489         }
490 
491         return this;
492     }
493 
494     /** {@inheritDoc} */
495     public MessageHolder newSevereMessage()
496     {
497         if ( isSevereEnabled() )
498         {
499             newMessage( MessageLevels.LEVEL_SEVERE );
500         }
501 
502         return this;
503     }
504 
505     /** {@inheritDoc} */
506     public MessageHolder newWarningMessage()
507     {
508         if ( isWarningEnabled() )
509         {
510             newMessage( MessageLevels.LEVEL_WARNING );
511         }
512 
513         return this;
514     }
515 
516     /** {@inheritDoc} */
517     public void setDebugEnabled( boolean enabled )
518     {
519         messageLevelStates[MessageLevels.LEVEL_DEBUG] = enabled;
520     }
521 
522     /** {@inheritDoc} */
523     public void setErrorEnabled( boolean enabled )
524     {
525         messageLevelStates[MessageLevels.LEVEL_ERROR] = enabled;
526     }
527 
528     /** {@inheritDoc} */
529     public void setInfoEnabled( boolean enabled )
530     {
531         messageLevelStates[MessageLevels.LEVEL_INFO] = enabled;
532     }
533 
534     /** {@inheritDoc} */
535     public void setSevereEnabled( boolean enabled )
536     {
537         messageLevelStates[MessageLevels.LEVEL_SEVERE] = enabled;
538     }
539 
540     /** {@inheritDoc} */
541     public void setWarningEnabled( boolean enabled )
542     {
543         messageLevelStates[MessageLevels.LEVEL_WARNING] = enabled;
544     }
545 
546     /** {@inheritDoc} */
547     public void flush()
548     {
549         if ( onDemandSink != null && currentMessage != null )
550         {
551             renderTo( currentMessage, onDemandSink );
552             currentMessage = null;
553         }
554     }
555 
556     /** {@inheritDoc} */
557     public void render( MessageSink sink )
558     {
559         for ( Message message : messages )
560         {
561             renderTo( message, sink );
562         }
563     }
564 
565     /**
566      * @param message {@link Message}
567      * @param sink {@link MessageSink}
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 }