Coverage Report

 /*
  * Copyright 2005-2007 The Kuali Foundation
  *
  * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
  *
  * 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.
  */
 package org.kuali.rice.kns.util;
 
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
 import org.kuali.rice.kew.engine.RouteContext;
 import org.kuali.rice.kns.UserSession;
 import org.kuali.rice.kns.web.struts.form.KualiForm;
 
 /**
  * This class will hold all of our thread local variables and accessors for those
  *
  *
  */
 public class GlobalVariables {
 
     private static ThreadLocal<UserSession> userSessions = new ThreadLocal<UserSession>();
     private static ThreadLocal<String> hideSessionFromTestsMessage = new ThreadLocal<String>();
     private static ThreadLocal<KualiForm> kualiForms = new ThreadLocal<KualiForm>();
     
     private static ThreadLocal<MessageMap> messageMaps = new ThreadLocal<MessageMap>()  {
                 protected MessageMap initialValue() {
                         return new MessageMap();
                 }
         };
         
     // todo: generic collections
     private static ThreadLocal<MessageList> messageLists = new ThreadLocal<MessageList>() {
                 protected MessageList initialValue() {
                         return new MessageList();
                 }
         };
         
     private static ThreadLocal<HashMap> auditErrorMaps = new ThreadLocal<HashMap>() {
             protected HashMap initialValue() {
                     return new HashMap();
             }
     };
     
     private static ThreadLocal<Map<String,Object>> requestCaches = new ThreadLocal<Map<String,Object>>() {
             protected HashMap<String, Object> initialValue() {
                     return new HashMap<String, Object>();
             }
     };
 
     /**
      * @return the UserSession that has been assigned to this thread of execution it is important that this not be called by
      *         anything that lives outside
      */
     public static UserSession getUserSession() {
         String message = hideSessionFromTestsMessage.get();
         if (message != null) {
             throw new RuntimeException(message);
         }
         return userSessions.get();
     }
 
     /**
      * Sets an error message for tests that try to use the session without declaring it.
      * This method should be use by only KualiTestBase, not by other test code and especially not by production code.
      *
      * @param message the detail to throw, or null to allow access to the session
      */
     public static void setHideSessionFromTestsMessage(String message) {
         hideSessionFromTestsMessage.set(message);
     }
 
     /**
      * sets the userSession object into the global variable for this thread
      *
      * @param userSession
      */
     public static void setUserSession(UserSession userSession) {
         userSessions.set(userSession);
     }
 
     /**
      * @deprecated use {@link #getMessageMap()} instead.
      * 
      * @return ErrorMap containing error messages.
      */
     @Deprecated
     public static ErrorMap getErrorMap() {
         return new ErrorMap(getMessageMap());
     }
     
     public static MessageMap getMessageMap() {
             return messageMaps.get();
     }
 
     /**
      * Merges a message map into the global variables error map
      * @param messageMap
      */
     public static void mergeErrorMap(MessageMap messageMap) {
         getMessageMap().getErrorMessages().putAll(messageMap.getErrorMessages());
         getMessageMap().getWarningMessages().putAll(messageMap.getWarningMessages());
         getMessageMap().getInfoMessages().putAll(messageMap.getInfoMessages());
     }
     
     /**
      * Sets a new (clean) MessageMap
      *
      * @param messageMap
      */
     public static void setMessageMap(MessageMap messageMap) {
             messageMaps.set(messageMap);
     }
 
     /**
      * Sets a new (clean) ErrorMap
      *
      * @deprecated use {@link #setMessageMap(MessageMap)} instead
      *
      * @param errorMap
      */
     @Deprecated
     public static void setErrorMap(ErrorMap errorMap) {
             setMessageMap(errorMap);
     }
 
     /**
      * @return ArrayList containing messages.
      */
     public static MessageList getMessageList() {
         return messageLists.get();
     }
 
     /**
      * Sets a new message list
      *
      * @param messageList
      */
     public static void setMessageList(MessageList messageList) {
         messageLists.set(messageList);
     }
 
     /**
      * @return ArrayList containing audit error messages.
      */
     public static HashMap getAuditErrorMap() {
         return auditErrorMaps.get();
     }
 
     /**
      * Sets a new (clean) AuditErrorList
      *
      * @param errorMap
      */
     public static void setAuditErrorMap(HashMap errorMap) {
         auditErrorMaps.set(errorMap);
     }
 
     /**
      * @return KualiForm that has been assigned to this thread of execution.
      */
     public static KualiForm getKualiForm() {
         return kualiForms.get();
     }
 
     /**
      * sets the kualiForm object into the global variable for this thread
      *
      * @param kualiForm
      */
     public static void setKualiForm(KualiForm kualiForm) {
             kualiForms.set(kualiForm);
     }
 
     public static Object getRequestCache( String cacheName ) {
             return requestCaches.get().get(cacheName);
     }
 
     public static void setRequestCache( String cacheName, Object cacheObject ) {
             requestCaches.get().put(cacheName, cacheObject);
     }
 
 
     /**
      * Clears out GlobalVariable objects with the exception of the UserSession
      */
     public static void clear() {
         messageMaps.set(new MessageMap());
         auditErrorMaps.set(new HashMap());
         messageLists.set(new MessageList());
         requestCaches.set(new HashMap<String,Object>() );
         kualiForms.set(null);
     }
 }

1		/*
2		* Copyright 2005-2007 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.kns.util;
17
18		import java.util.HashMap;
19		import java.util.LinkedList;
20		import java.util.List;
21		import java.util.Map;
22
23		import org.kuali.rice.kew.engine.RouteContext;
24		import org.kuali.rice.kns.UserSession;
25		import org.kuali.rice.kns.web.struts.form.KualiForm;
26
27		/**
28		* This class will hold all of our thread local variables and accessors for those
29		*
30		*
31		*/
32	0	public class GlobalVariables {
33
34	0	private static ThreadLocal<UserSession> userSessions = new ThreadLocal<UserSession>();
35	0	private static ThreadLocal<String> hideSessionFromTestsMessage = new ThreadLocal<String>();
36	0	private static ThreadLocal<KualiForm> kualiForms = new ThreadLocal<KualiForm>();
37
38	0	private static ThreadLocal<MessageMap> messageMaps = new ThreadLocal<MessageMap>() {
39		protected MessageMap initialValue() {
40	0	return new MessageMap();
41		}
42		};
43
44		// todo: generic collections
45	0	private static ThreadLocal<MessageList> messageLists = new ThreadLocal<MessageList>() {
46		protected MessageList initialValue() {
47	0	return new MessageList();
48		}
49		};
50
51	0	private static ThreadLocal<HashMap> auditErrorMaps = new ThreadLocal<HashMap>() {
52		protected HashMap initialValue() {
53	0	return new HashMap();
54		}
55		};
56
57	0	private static ThreadLocal<Map<String,Object>> requestCaches = new ThreadLocal<Map<String,Object>>() {
58		protected HashMap<String, Object> initialValue() {
59	0	return new HashMap<String, Object>();
60		}
61		};
62
63		/**
64		* @return the UserSession that has been assigned to this thread of execution it is important that this not be called by
65		* anything that lives outside
66		*/
67		public static UserSession getUserSession() {
68	0	String message = hideSessionFromTestsMessage.get();
69	0	if (message != null) {
70	0	throw new RuntimeException(message);
71		}
72	0	return userSessions.get();
73		}
74
75		/**
76		* Sets an error message for tests that try to use the session without declaring it.
77		* This method should be use by only KualiTestBase, not by other test code and especially not by production code.
78		*
79		* @param message the detail to throw, or null to allow access to the session
80		*/
81		public static void setHideSessionFromTestsMessage(String message) {
82	0	hideSessionFromTestsMessage.set(message);
83	0	}
84
85		/**
86		* sets the userSession object into the global variable for this thread
87		*
88		* @param userSession
89		*/
90		public static void setUserSession(UserSession userSession) {
91	0	userSessions.set(userSession);
92	0	}
93
94		/**
95		* @deprecated use {@link #getMessageMap()} instead.
96		*
97		* @return ErrorMap containing error messages.
98		*/
99		@Deprecated
100		public static ErrorMap getErrorMap() {
101	0	return new ErrorMap(getMessageMap());
102		}
103
104		public static MessageMap getMessageMap() {
105	0	return messageMaps.get();
106		}
107
108		/**
109		* Merges a message map into the global variables error map
110		* @param messageMap
111		*/
112		public static void mergeErrorMap(MessageMap messageMap) {
113	0	getMessageMap().getErrorMessages().putAll(messageMap.getErrorMessages());
114	0	getMessageMap().getWarningMessages().putAll(messageMap.getWarningMessages());
115	0	getMessageMap().getInfoMessages().putAll(messageMap.getInfoMessages());
116	0	}
117
118		/**
119		* Sets a new (clean) MessageMap
120		*
121		* @param messageMap
122		*/
123		public static void setMessageMap(MessageMap messageMap) {
124	0	messageMaps.set(messageMap);
125	0	}
126
127		/**
128		* Sets a new (clean) ErrorMap
129		*
130		* @deprecated use {@link #setMessageMap(MessageMap)} instead
131		*
132		* @param errorMap
133		*/
134		@Deprecated
135		public static void setErrorMap(ErrorMap errorMap) {
136	0	setMessageMap(errorMap);
137	0	}
138
139		/**
140		* @return ArrayList containing messages.
141		*/
142		public static MessageList getMessageList() {
143	0	return messageLists.get();
144		}
145
146		/**
147		* Sets a new message list
148		*
149		* @param messageList
150		*/
151		public static void setMessageList(MessageList messageList) {
152	0	messageLists.set(messageList);
153	0	}
154
155		/**
156		* @return ArrayList containing audit error messages.
157		*/
158		public static HashMap getAuditErrorMap() {
159	0	return auditErrorMaps.get();
160		}
161
162		/**
163		* Sets a new (clean) AuditErrorList
164		*
165		* @param errorMap
166		*/
167		public static void setAuditErrorMap(HashMap errorMap) {
168	0	auditErrorMaps.set(errorMap);
169	0	}
170
171		/**
172		* @return KualiForm that has been assigned to this thread of execution.
173		*/
174		public static KualiForm getKualiForm() {
175	0	return kualiForms.get();
176		}
177
178		/**
179		* sets the kualiForm object into the global variable for this thread
180		*
181		* @param kualiForm
182		*/
183		public static void setKualiForm(KualiForm kualiForm) {
184	0	kualiForms.set(kualiForm);
185	0	}
186
187		public static Object getRequestCache( String cacheName ) {
188	0	return requestCaches.get().get(cacheName);
189		}
190
191		public static void setRequestCache( String cacheName, Object cacheObject ) {
192	0	requestCaches.get().put(cacheName, cacheObject);
193	0	}
194
195
196		/**
197		* Clears out GlobalVariable objects with the exception of the UserSession
198		*/
199		public static void clear() {
200	0	messageMaps.set(new MessageMap());
201	0	auditErrorMaps.set(new HashMap());
202	0	messageLists.set(new MessageList());
203	0	requestCaches.set(new HashMap<String,Object>() );
204	0	kualiForms.set(null);
205	0	}
206		}