Coverage Report

Coverage Report - org.apache.maven.shared.io.logging.DefaultMessageHolder

Classes in this File

Line Coverage

Branch Coverage

Complexity

DefaultMessageHolder

36 %

50/140

31 %

14/45

1,41

DefaultMessageHolder$Message

100 %

24/24

80 %

8/10

1,41

 package org.apache.maven.shared.io.logging;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
 public class DefaultMessageHolder
     implements MessageHolder
 {
 
     private List messages = new ArrayList();
 
     private Message currentMessage;
 
     private int defaultMessageLevel = MessageLevels.LEVEL_INFO;
 
     private boolean[] messageLevelStates;
 
     private MessageSink onDemandSink;
 
     public DefaultMessageHolder()
     {
         this.messageLevelStates = MessageLevels.getLevelStates( MessageLevels.LEVEL_INFO );
     }
 
     public DefaultMessageHolder( int maxMessageLevel, int defaultMessageLevel )
     {
         this.defaultMessageLevel = defaultMessageLevel;
         this.messageLevelStates = MessageLevels.getLevelStates( maxMessageLevel );
     }
 
     public DefaultMessageHolder( int maxMessageLevel, int defaultMessageLevel, MessageSink onDemandSink )
     {
         this.defaultMessageLevel = defaultMessageLevel;
         this.onDemandSink = onDemandSink;
         this.messageLevelStates = MessageLevels.getLevelStates( maxMessageLevel );
     }
 
     public MessageHolder addMessage( CharSequence messagePart, Throwable error )
     {
         return addMessage( defaultMessageLevel, messagePart, error );
     }
 
     protected MessageHolder addMessage( int level, CharSequence messagePart, Throwable error )
     {
         newMessage( level );
         append( messagePart.toString() );
         append( error );
 
         return this;
     }
 
     public MessageHolder addMessage( CharSequence messagePart )
     {
         return addMessage( defaultMessageLevel, messagePart );
     }
 
     protected MessageHolder addMessage( int level, CharSequence messagePart )
     {
         newMessage( level );
         append( messagePart.toString() );
 
         return this;
     }
 
     public MessageHolder addMessage( Throwable error )
     {
         return addMessage( defaultMessageLevel, error );
     }
 
     protected MessageHolder addMessage( int level, Throwable error )
     {
         newMessage( level );
         append( error );
 
         return this;
     }
 
     public MessageHolder append( CharSequence messagePart )
     {
         if ( currentMessage == null )
         {
             newMessage();
         }
 
         currentMessage.append( messagePart.toString() );
 
         return this;
     }
 
     public MessageHolder append( Throwable error )
     {
         if ( currentMessage == null )
         {
             newMessage();
         }
 
         currentMessage.setError( error );
 
         return this;
     }
 
     public boolean isEmpty()
     {
         return messages.isEmpty();
     }
 
     public MessageHolder newMessage()
     {
         newMessage( defaultMessageLevel );
 
         return this;
     }
 
     protected void newMessage( int messageLevel )
     {
         if ( onDemandSink != null && currentMessage != null )
         {
             renderTo( currentMessage, onDemandSink );
         }
 
         currentMessage = new Message( messageLevel, onDemandSink );
         messages.add( currentMessage );
     }
 
     public String render()
     {
         StringBuffer buffer = new StringBuffer();
 
         int counter = 1;
         for ( Iterator it = messages.iterator(); it.hasNext(); )
         {
             Message message = (Message) it.next();
 
             int ml = message.getMessageLevel();
 
             if ( ml >= messageLevelStates.length || ml < 0 )
             {
                 ml = MessageLevels.LEVEL_DEBUG;
             }
 
             if ( !messageLevelStates[ml] )
             {
                 continue;
             }
 
             CharSequence content = message.render();
             String label = MessageLevels.getLevelLabel( message.getMessageLevel() );
 
             if ( content.length() > label.length() + 3 )
             {
                 buffer.append( '[' ).append( counter++ ).append( "] " );
                 buffer.append( content.toString() );
 
                 if ( it.hasNext() )
                 {
                     buffer.append( "\n\n" );
                 }
             }
         }
 
         return buffer.toString();
     }
 
     public int size()
     {
         return messages.size();
     }
 
     private static final class Message
     {
         private StringBuffer message = new StringBuffer();
 
         private Throwable error;
 
         private final int messageLevel;
 
         private final MessageSink onDemandSink;
 
         public Message( int messageLevel, MessageSink onDemandSink )
         {
             this.messageLevel = messageLevel;
 
             this.onDemandSink = onDemandSink;
         }
 
         public Message setError( Throwable error )
         {
             this.error = error;
             return this;
         }
 
         public Message append( CharSequence message )
         {
             this.message.append( message.toString() );
             return this;
         }
 
         public int getMessageLevel()
         {
             return messageLevel;
         }
 
         public CharSequence render()
         {
             StringBuffer buffer = new StringBuffer();
 
             if ( onDemandSink == null )
             {
                 buffer.append( '[' ).append( MessageLevels.getLevelLabel( messageLevel ) ).append( "] " );
             }
             if ( message != null && message.length() > 0 )
             {
                 buffer.append( message );
 
                 if ( error != null )
                 {
                     buffer.append( '\n' );
                 }
             }
 
             if ( error != null )
             {
                 buffer.append( "Error:\n" );
 
                 StringWriter sw = new StringWriter();
                 PrintWriter pw = new PrintWriter( sw );
                 error.printStackTrace( pw );
 
                 buffer.append( sw.toString() );
             }
 
             return buffer;
         }
     }
 
     public MessageHolder addDebugMessage( CharSequence messagePart, Throwable error )
     {
         return addMessage( MessageLevels.LEVEL_DEBUG, messagePart, error );
     }
 
     public MessageHolder addDebugMessage( CharSequence messagePart )
     {
         return addMessage( MessageLevels.LEVEL_DEBUG, messagePart );
     }
 
     public MessageHolder addDebugMessage( Throwable error )
     {
         return addMessage( MessageLevels.LEVEL_DEBUG, error );
     }
 
     public MessageHolder addErrorMessage( CharSequence messagePart, Throwable error )
     {
         return addMessage( MessageLevels.LEVEL_ERROR, messagePart, error );
     }
 
     public MessageHolder addErrorMessage( CharSequence messagePart )
     {
         return addMessage( MessageLevels.LEVEL_ERROR, messagePart );
     }
 
     public MessageHolder addErrorMessage( Throwable error )
     {
         return addMessage( MessageLevels.LEVEL_ERROR, error );
     }
 
     public MessageHolder addInfoMessage( CharSequence messagePart, Throwable error )
     {
         return addMessage( MessageLevels.LEVEL_INFO, messagePart, error );
     }
 
     public MessageHolder addInfoMessage( CharSequence messagePart )
     {
         return addMessage( MessageLevels.LEVEL_INFO, messagePart );
     }
 
     public MessageHolder addInfoMessage( Throwable error )
     {
         return addMessage( MessageLevels.LEVEL_INFO, error );
     }
 
     public MessageHolder addSevereMessage( CharSequence messagePart, Throwable error )
     {
         return addMessage( MessageLevels.LEVEL_SEVERE, messagePart, error );
     }
 
     public MessageHolder addSevereMessage( CharSequence messagePart )
     {
         return addMessage( MessageLevels.LEVEL_SEVERE, messagePart );
     }
 
     public MessageHolder addSevereMessage( Throwable error )
     {
         return addMessage( MessageLevels.LEVEL_SEVERE, error );
     }
 
     public MessageHolder addWarningMessage( CharSequence messagePart, Throwable error )
     {
         return addMessage( MessageLevels.LEVEL_WARNING, messagePart, error );
     }
 
     public MessageHolder addWarningMessage( CharSequence messagePart )
     {
         return addMessage( MessageLevels.LEVEL_WARNING, messagePart );
     }
 
     public MessageHolder addWarningMessage( Throwable error )
     {
         return addMessage( MessageLevels.LEVEL_WARNING, error );
     }
 
     public int countDebugMessages()
     {
         return countMessagesOfType( MessageLevels.LEVEL_DEBUG );
     }
 
     public int countErrorMessages()
     {
         return countMessagesOfType( MessageLevels.LEVEL_ERROR );
     }
 
     public int countInfoMessages()
     {
         return countMessagesOfType( MessageLevels.LEVEL_INFO );
     }
 
     public int countMessages()
     {
         return size();
     }
 
     public int countSevereMessages()
     {
         return countMessagesOfType( MessageLevels.LEVEL_SEVERE );
     }
 
     public int countWarningMessages()
     {
         return countMessagesOfType( MessageLevels.LEVEL_WARNING );
     }
 
     private int countMessagesOfType( int messageLevel )
     {
         int count = 0;
 
         for ( Iterator it = messages.iterator(); it.hasNext(); )
         {
             Message message = (Message) it.next();
             if ( messageLevel == message.getMessageLevel() )
             {
                 count++;
             }
         }
 
         return count;
     }
 
     public boolean isDebugEnabled()
     {
         return messageLevelStates[MessageLevels.LEVEL_DEBUG];
     }
 
     public boolean isErrorEnabled()
     {
         return messageLevelStates[MessageLevels.LEVEL_ERROR];
     }
 
     public boolean isInfoEnabled()
     {
         return messageLevelStates[MessageLevels.LEVEL_INFO];
     }
 
     public boolean isSevereEnabled()
     {
         return messageLevelStates[MessageLevels.LEVEL_SEVERE];
     }
 
     public boolean isWarningEnabled()
     {
         return messageLevelStates[MessageLevels.LEVEL_WARNING];
     }
 
     public MessageHolder newDebugMessage()
     {
         if ( isDebugEnabled() )
         {
             newMessage( MessageLevels.LEVEL_DEBUG );
         }
 
         return this;
     }
 
     public MessageHolder newErrorMessage()
     {
         if ( isErrorEnabled() )
         {
             newMessage( MessageLevels.LEVEL_ERROR );
         }
 
         return this;
     }
 
     public MessageHolder newInfoMessage()
     {
         if ( isInfoEnabled() )
         {
             newMessage( MessageLevels.LEVEL_INFO );
         }
 
         return this;
     }
 
     public MessageHolder newSevereMessage()
     {
         if ( isSevereEnabled() )
         {
             newMessage( MessageLevels.LEVEL_SEVERE );
         }
 
         return this;
     }
 
     public MessageHolder newWarningMessage()
     {
         if ( isWarningEnabled() )
         {
             newMessage( MessageLevels.LEVEL_WARNING );
         }
 
         return this;
     }
 
     public void setDebugEnabled( boolean enabled )
     {
         messageLevelStates[MessageLevels.LEVEL_DEBUG] = enabled;
     }
 
     public void setErrorEnabled( boolean enabled )
     {
         messageLevelStates[MessageLevels.LEVEL_ERROR] = enabled;
     }
 
     public void setInfoEnabled( boolean enabled )
     {
         messageLevelStates[MessageLevels.LEVEL_INFO] = enabled;
     }
 
     public void setSevereEnabled( boolean enabled )
     {
         messageLevelStates[MessageLevels.LEVEL_SEVERE] = enabled;
     }
 
     public void setWarningEnabled( boolean enabled )
     {
         messageLevelStates[MessageLevels.LEVEL_WARNING] = enabled;
     }
 
     public void flush()
     {
         if ( onDemandSink != null && currentMessage != null )
         {
             renderTo( currentMessage, onDemandSink );
             currentMessage = null;
         }
     }
 
     public void render( MessageSink sink )
     {
         for ( Iterator it = messages.iterator(); it.hasNext(); )
         {
             Message message = (Message) it.next();
 
             renderTo( message, sink );
         }
     }
 
     protected void renderTo( Message message, MessageSink sink )
     {
         switch( message.getMessageLevel() )
         {
         case( MessageLevels.LEVEL_SEVERE ):
         {
             sink.severe( message.render().toString() );
             break;
         }
         case( MessageLevels.LEVEL_ERROR ):
         {
             sink.error( message.render().toString() );
             break;
         }
         case( MessageLevels.LEVEL_WARNING ):
         {
             sink.warning( message.render().toString() );
             break;
         }
         case( MessageLevels.LEVEL_INFO ):
         {
             sink.info( message.render().toString() );
             break;
         }
         default:
         {
             sink.debug( message.render().toString() );
             break;
         }
         }
     }
 
 }

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