Coverage Report

Coverage Report - org.codeforamerica.open311.internals.logging.LogManager

Classes in this File

Line Coverage

Branch Coverage

Complexity

LogManager

58%

10/17

50%

2/4

1.286

 package org.codeforamerica.open311.internals.logging;
 
 import java.util.HashSet;
 import java.util.Set;
 
 import org.codeforamerica.open311.internals.platform.PlatformManager;
 
 /**
  * Manages all the login related operations.
  * 
  * Singleton class.
  * 
  * @author Santiago Munín <santimunin@gmail.com>
  * 
  */
 public class LogManager {
         /**
          * Unique instance of the logger.
          */
         private Logger logger = PlatformManager.getInstance().buildLogger();
         /**
          * Unique instance of the class.
          */
         private static LogManager instance = new LogManager();
         /**
          * Contains a wrapper if it has to be logged.
          */
         private static Set<Object> loggedObjects = new HashSet<Object>();
 
         /**
          * Prevents other classes to instantiate this class.
          */
         private LogManager() {
         }
 
         /**
          * Returns the unique instance of the class.
          * 
          * @return unique instance of the class.
          */
         public static LogManager getInstance() {
                 return instance;
         }
 
         /**
          * Activates the logging for a concrete wrapper.
          * 
          * @param objectToBeLogged
          *            Object to be logged.
          */
         public void activate(Object objectToBeLogged) {
                 loggedObjects.add(objectToBeLogged);
         }
 
         /**
          * Disables the logging for a concrete wrapper.
          * 
          * @param loggedObject
          *            Object which logging will be disabled.
          */
         public void disable(Object loggedObject) {
                 loggedObjects.remove(loggedObject);
         }
 
         /**
          * Logs a non-critical event.
          * 
          * @param messageCreator
          *            origin of the message.
          * @param message
          *            Event message.
          */
         public void logInfo(Object messageCreator, String message) {
                 if (loggedObjects.contains(messageCreator)) {
                         logger.logInfo(buildMessage(messageCreator, message));
                 }
         }
 
         /**
          * Logs any problem.
          * 
          * @param messageCreator
          *            origin of the message.
          * @param message
          *            Event message.
          */
         public void logError(Object messageCreator, String message) {
                 if (loggedObjects.contains(messageCreator)) {
                         logger.logError(buildMessage(messageCreator, message));
                 }
         }
 
         /**
          * Builds a log message containing the wrapper information.
          * 
          * @param messageCreator
          *            origin of the message.
          * 
          * @param message
          *            Event message.
          * @return
          */
         private static String buildMessage(Object messageCreator, String message) {
                 return "(" + messageCreator + ") --> " + message;
         }
 }

1		package org.codeforamerica.open311.internals.logging;
2
3		import java.util.HashSet;
4		import java.util.Set;
5
6		import org.codeforamerica.open311.internals.platform.PlatformManager;
7
8		/**
9		* Manages all the login related operations.
10		*
11		* Singleton class.
12		*
13		* @author Santiago Munín <santimunin@gmail.com>
14		*
15		*/
16		public class LogManager {
17		/**
18		* Unique instance of the logger.
19		*/
20	1	private Logger logger = PlatformManager.getInstance().buildLogger();
21		/**
22		* Unique instance of the class.
23		*/
24	1	private static LogManager instance = new LogManager();
25		/**
26		* Contains a wrapper if it has to be logged.
27		*/
28	1	private static Set<Object> loggedObjects = new HashSet<Object>();
29
30		/**
31		* Prevents other classes to instantiate this class.
32		*/
33	1	private LogManager() {
34	1	}
35
36		/**
37		* Returns the unique instance of the class.
38		*
39		* @return unique instance of the class.
40		*/
41		public static LogManager getInstance() {
42	17	return instance;
43		}
44
45		/**
46		* Activates the logging for a concrete wrapper.
47		*
48		* @param objectToBeLogged
49		* Object to be logged.
50		*/
51		public void activate(Object objectToBeLogged) {
52	0	loggedObjects.add(objectToBeLogged);
53	0	}
54
55		/**
56		* Disables the logging for a concrete wrapper.
57		*
58		* @param loggedObject
59		* Object which logging will be disabled.
60		*/
61		public void disable(Object loggedObject) {
62	0	loggedObjects.remove(loggedObject);
63	0	}
64
65		/**
66		* Logs a non-critical event.
67		*
68		* @param messageCreator
69		* origin of the message.
70		* @param message
71		* Event message.
72		*/
73		public void logInfo(Object messageCreator, String message) {
74	75	if (loggedObjects.contains(messageCreator)) {
75	0	logger.logInfo(buildMessage(messageCreator, message));
76		}
77	75	}
78
79		/**
80		* Logs any problem.
81		*
82		* @param messageCreator
83		* origin of the message.
84		* @param message
85		* Event message.
86		*/
87		public void logError(Object messageCreator, String message) {
88	2	if (loggedObjects.contains(messageCreator)) {
89	0	logger.logError(buildMessage(messageCreator, message));
90		}
91	2	}
92
93		/**
94		* Builds a log message containing the wrapper information.
95		*
96		* @param messageCreator
97		* origin of the message.
98		*
99		* @param message
100		* Event message.
101		* @return
102		*/
103		private static String buildMessage(Object messageCreator, String message) {
104	0	return "(" + messageCreator + ") --> " + message;
105		}
106		}