Coverage Report

Coverage Report - org.apache.maven.doxia.logging.PlexusLoggerWrapper

Classes in this File

Line Coverage

Branch Coverage

Complexity

PlexusLoggerWrapper

0/44

0/10

1,316

 package org.apache.maven.doxia.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 org.codehaus.plexus.logging.Logger;
 
 /**
  * Wrap a Plexus logger into a Doxia logger.
  * Based on org.apache.maven.plugin.logging.Log.
  *
  * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
  * @version $Id: PlexusLoggerWrapper.java 785531 2009-06-17 09:47:59Z ltheussl $
  * @since 1.1
  */
 public class PlexusLoggerWrapper
     implements Log
 {
     private final Logger logger;
 
     /**
      * <p>Constructor for PlexusLoggerWrapper.</p>
      *
      * @param logger the Plexus logger to wrap.
      */
     public PlexusLoggerWrapper( Logger logger )
     {
         this.logger = logger;
     }
 
     /** {@inheritDoc} */
     public void setLogLevel( int level )
     {
         if ( level <= LEVEL_DEBUG )
         {
             logger.setThreshold( Logger.LEVEL_DEBUG );
         }
         else if ( level <= LEVEL_INFO )
         {
             logger.setThreshold( Logger.LEVEL_INFO );
         }
         else if ( level <= LEVEL_WARN )
         {
             logger.setThreshold( Logger.LEVEL_WARN );
         }
         else if ( level <= LEVEL_ERROR )
         {
             logger.setThreshold( Logger.LEVEL_ERROR );
         }
         else
         {
             logger.setThreshold( Logger.LEVEL_DISABLED );
         }
     }
 
     /** {@inheritDoc} */
     public void debug( CharSequence content )
     {
         logger.debug( toString( content ) );
     }
 
     /** {@inheritDoc} */
     public void debug( CharSequence content, Throwable error )
     {
         logger.debug( toString( content ), error );
     }
 
     /** {@inheritDoc} */
     public void debug( Throwable error )
     {
         logger.debug( "", error );
     }
 
     /** {@inheritDoc} */
     public void info( CharSequence content )
     {
         logger.info( toString( content ) );
     }
 
     /** {@inheritDoc} */
     public void info( CharSequence content, Throwable error )
     {
         logger.info( toString( content ), error );
     }
 
     /** {@inheritDoc} */
     public void info( Throwable error )
     {
         logger.info( "", error );
     }
 
     /** {@inheritDoc} */
     public void warn( CharSequence content )
     {
         logger.warn( toString( content ) );
     }
 
     /** {@inheritDoc} */
     public void warn( CharSequence content, Throwable error )
     {
         logger.warn( toString( content ), error );
     }
 
     /** {@inheritDoc} */
     public void warn( Throwable error )
     {
         logger.warn( "", error );
     }
 
     /** {@inheritDoc} */
     public void error( CharSequence content )
     {
         logger.error( toString( content ) );
     }
 
     /** {@inheritDoc} */
     public void error( CharSequence content, Throwable error )
     {
         logger.error( toString( content ), error );
     }
 
     /** {@inheritDoc} */
     public void error( Throwable error )
     {
         logger.error( "", error );
     }
 
     /** {@inheritDoc} */
     public boolean isDebugEnabled()
     {
         return logger.isDebugEnabled();
     }
 
     /** {@inheritDoc} */
     public boolean isInfoEnabled()
     {
         return logger.isInfoEnabled();
     }
 
     /** {@inheritDoc} */
     public boolean isWarnEnabled()
     {
         return logger.isWarnEnabled();
     }
 
     /** {@inheritDoc} */
     public boolean isErrorEnabled()
     {
         return logger.isErrorEnabled();
     }
 
     // ----------------------------------------------------------------------
     // Private methods
     // ----------------------------------------------------------------------
 
     private String toString( CharSequence content )
     {
         if ( content == null )
         {
             return "";
         }
 
         return content.toString();
     }
 }

1		package org.apache.maven.doxia.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 org.codehaus.plexus.logging.Logger;
23
24		/**
25		* Wrap a Plexus logger into a Doxia logger.
26		* Based on org.apache.maven.plugin.logging.Log.
27		*
28		* @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
29		* @version $Id: PlexusLoggerWrapper.java 785531 2009-06-17 09:47:59Z ltheussl $
30		* @since 1.1
31		*/
32		public class PlexusLoggerWrapper
33		implements Log
34		{
35		private final Logger logger;
36
37		/**
38		* <p>Constructor for PlexusLoggerWrapper.</p>
39		*
40		* @param logger the Plexus logger to wrap.
41		*/
42		public PlexusLoggerWrapper( Logger logger )
43	0	{
44	0	this.logger = logger;
45	0	}
46
47		/** {@inheritDoc} */
48		public void setLogLevel( int level )
49		{
50	0	if ( level <= LEVEL_DEBUG )
51		{
52	0	logger.setThreshold( Logger.LEVEL_DEBUG );
53		}
54	0	else if ( level <= LEVEL_INFO )
55		{
56	0	logger.setThreshold( Logger.LEVEL_INFO );
57		}
58	0	else if ( level <= LEVEL_WARN )
59		{
60	0	logger.setThreshold( Logger.LEVEL_WARN );
61		}
62	0	else if ( level <= LEVEL_ERROR )
63		{
64	0	logger.setThreshold( Logger.LEVEL_ERROR );
65		}
66		else
67		{
68	0	logger.setThreshold( Logger.LEVEL_DISABLED );
69		}
70	0	}
71
72		/** {@inheritDoc} */
73		public void debug( CharSequence content )
74		{
75	0	logger.debug( toString( content ) );
76	0	}
77
78		/** {@inheritDoc} */
79		public void debug( CharSequence content, Throwable error )
80		{
81	0	logger.debug( toString( content ), error );
82	0	}
83
84		/** {@inheritDoc} */
85		public void debug( Throwable error )
86		{
87	0	logger.debug( "", error );
88	0	}
89
90		/** {@inheritDoc} */
91		public void info( CharSequence content )
92		{
93	0	logger.info( toString( content ) );
94	0	}
95
96		/** {@inheritDoc} */
97		public void info( CharSequence content, Throwable error )
98		{
99	0	logger.info( toString( content ), error );
100	0	}
101
102		/** {@inheritDoc} */
103		public void info( Throwable error )
104		{
105	0	logger.info( "", error );
106	0	}
107
108		/** {@inheritDoc} */
109		public void warn( CharSequence content )
110		{
111	0	logger.warn( toString( content ) );
112	0	}
113
114		/** {@inheritDoc} */
115		public void warn( CharSequence content, Throwable error )
116		{
117	0	logger.warn( toString( content ), error );
118	0	}
119
120		/** {@inheritDoc} */
121		public void warn( Throwable error )
122		{
123	0	logger.warn( "", error );
124	0	}
125
126		/** {@inheritDoc} */
127		public void error( CharSequence content )
128		{
129	0	logger.error( toString( content ) );
130	0	}
131
132		/** {@inheritDoc} */
133		public void error( CharSequence content, Throwable error )
134		{
135	0	logger.error( toString( content ), error );
136	0	}
137
138		/** {@inheritDoc} */
139		public void error( Throwable error )
140		{
141	0	logger.error( "", error );
142	0	}
143
144		/** {@inheritDoc} */
145		public boolean isDebugEnabled()
146		{
147	0	return logger.isDebugEnabled();
148		}
149
150		/** {@inheritDoc} */
151		public boolean isInfoEnabled()
152		{
153	0	return logger.isInfoEnabled();
154		}
155
156		/** {@inheritDoc} */
157		public boolean isWarnEnabled()
158		{
159	0	return logger.isWarnEnabled();
160		}
161
162		/** {@inheritDoc} */
163		public boolean isErrorEnabled()
164		{
165	0	return logger.isErrorEnabled();
166		}
167
168		// ----------------------------------------------------------------------
169		// Private methods
170		// ----------------------------------------------------------------------
171
172		private String toString( CharSequence content )
173		{
174	0	if ( content == null )
175		{
176	0	return "";
177		}
178
179	0	return content.toString();
180		}
181		}