Coverage Report

Coverage Report - org.kuali.student.lum.common.client.widgets.GregorianCalendar

Classes in this File

Line Coverage

Branch Coverage

Complexity

GregorianCalendar

0/180

0/173

4.967

 /**
  * Copyright 2010 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.osedu.org/licenses/ECL-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.
  */
 
 package org.kuali.student.lum.common.client.widgets;
 
 import java.util.Date;
 
 /**
  * <dl>
  * <dt><b>Title: </b><dd>GregorianCalendar</dd>
  * <p>
  * <dt><b>Description: </b><dd>java.util.GregorianCalendar replacment</dd>
  * </dl>
  * @author <a href="mailto:andre.freller@gmail.com">Andre Freller</a>
  * @version $Revision: 0.1 $
  */
 ///////// ///////// ///////// ///////// ///////// ///////// ///////// ///////// ///////// ///////// ///////// /////////
 public class GregorianCalendar extends Calendar
 {
     public static final int BC          = 0;
     public static final int AD          = 1;
 
     public GregorianCalendar() {
         super();
     }
     public GregorianCalendar(Date date) {
         setTime(date);
     }
     public GregorianCalendar(int year, int month, int date) {
         set(year, month, date);
     }
     public GregorianCalendar(int year, int month, int date, int hour) {
         set(year, month, date, hour);
     }
     public GregorianCalendar(int year, int month, int date, int hour, int minute) {
         set(year, month, date, hour, minute);
     }
     public GregorianCalendar(int year, int month, int date, int hour, int minute, int second) {
         set(year, month, date, hour, minute, second);
     }
 
     protected static int[] daysInMonth  = {31, 28, 31, 30, 31, 30, 31, 31 ,30, 31, 30, 31};
     public static int getMaxDaysInMonth(int year, int month) {
         if (month == Calendar.FEBRUARY  &&  isLeapYear(year))
             return daysInMonth[month] + 1;
         else
             return daysInMonth[month];
     }
     public int getMaxDaysInMonth() {
         return getMaxDaysInMonth(this.year, this.month);
     }
 
     public static int getNumOfWeeksInMonth(int year, int month, int firstDayOfWeek) {
         int day1        = getWeekDay(year, month, 1);
         int maxDays     = getMaxDaysInMonth(year, month);
         if (month == Calendar.FEBRUARY  &&  !isLeapYear(year)  &&  day1 == firstDayOfWeek)
             return 4;
         if (maxDays == 30  &&  (day1 > firstDayOfWeek + 5  ||  day1 < firstDayOfWeek))
             return 6;
         if (maxDays == 31  &&  (day1 > firstDayOfWeek + 4  ||  day1 < firstDayOfWeek))
             return 6;
         return 5;
     }
     public int getNumOfWeeksInMonth() {
         return getNumOfWeeksInMonth(this.year, this.month, this.firstWeekDayOfWeek);
     }
 
     public static int getWeekDay(int year, int month, int dayOfMonth) {
         int weekDay     = year - 1900;
         weekDay         += weekDay/4;
         weekDay         %= 7;
         if (month <= Calendar.FEBRUARY  &&  isLeapYear(weekDay))
             weekDay     -= 1;
         weekDay         += dayOfMonth;
         weekDay         %= 7;
         if (month == Calendar.MAY)
             weekDay     += 1;
         else if (month == Calendar.AUGUST)
             weekDay     += 2;
         else if (month == Calendar.FEBRUARY  ||  month == Calendar.MARCH  ||  month == Calendar.NOVEMBER)
             weekDay     += 3;
         else if (month == Calendar.JUNE)
             weekDay     += 4;
         else if (month == Calendar.SEPTEMBER  ||  month == Calendar.DECEMBER)
             weekDay     += 5;
         else if (month == Calendar.APRIL  ||  month == Calendar.JULY)
             weekDay     += 6;
         weekDay         %= 7;
 
         return Calendar.SUNDAY + weekDay;
     }
     public int getWeekDay() {
         return getWeekDay(this.year, this.month, this.dayOfMonth);
     }
     public int getFirstWeekDayOfMonth() {
         return getWeekDay(this.year, this.month, 1);
     }
 
     // Gets the minimum value for the given time field.
     public int getMinimum(int fieldCode) {
         switch (fieldCode) {
         case Calendar.MILLISECOND:
             return 0;
         case Calendar.SECOND:
             return 0;
         case Calendar.MINUTE:
             return 0;
         case Calendar.HOUR:
             return 0;
         case Calendar.HOUR_OF_DAY:
             return 0;
         case Calendar.DATE:
             return 1;
         case Calendar.MONTH:
             return Calendar.JANUARY;
         default:
             return -1;
         }
     }
     // Return the minimum value that this field could have, given the current date.
     public int getActualMinimum(int fieldCode) {
         return getMinimum(fieldCode);
     }
     // Gets the highest minimum value for the given field if varies.
     public   int getGreatestMinimum(int fieldCode) {
         return getMinimum(fieldCode);
     }
 
     // Gets the maximum value for the given time field.
     public   int getMaximum(int fieldCode) {
         switch (fieldCode) {
         case Calendar.MILLISECOND:
             return 999;
         case Calendar.SECOND:
             return 59;
         case Calendar.MINUTE:
             return 59;
         case Calendar.HOUR:
             return 11;
         case Calendar.HOUR_OF_DAY:
             return 23;
         case Calendar.DATE:
             return 31;
         case Calendar.MONTH:
             return Calendar.DECEMBER;
         default:
             return -1;
         }
     }
     // Return the maximum value that this field could have, given the current date.
     public int getActualMaximum(int fieldCode) {
         switch (fieldCode) {
         case Calendar.MILLISECOND:
             return 999;
         case Calendar.SECOND:
             return 59;
         case Calendar.MINUTE:
             return 59;
         case Calendar.HOUR:
             return 11;
         case Calendar.HOUR_OF_DAY:
             return 23;
         case Calendar.DATE:
             return getMaxDaysInMonth();
         case Calendar.MONTH:
             return Calendar.DECEMBER;
         default:
             return -1;
         }
     }
     // Gets the lowest maximum value for the given field if varies.
     public   int getLeastMaximum(int fieldCode) {
         switch (fieldCode) {
         case Calendar.MILLISECOND:
             return 999;
         case Calendar.SECOND:
             return 59;
         case Calendar.MINUTE:
             return 59;
         case Calendar.HOUR:
             return 11;
         case Calendar.HOUR_OF_DAY:
             return 23;
         case Calendar.DATE:
             return 28;
         case Calendar.MONTH:
             return Calendar.DECEMBER;
         default:
             return -1;
         }
     }
 
 
     public void set(int fieldCode, int value) {
         switch (fieldCode) {
         case Calendar.SECOND:
             this.second         = value;
             break;
         case Calendar.MINUTE:
             this.minute         = value;
             break;
         case Calendar.HOUR:
             this.hour           = value;
             break;
         case Calendar.HOUR_OF_DAY:
             if (value <= 12) {
                 this.hour       = value;
                 this.amPm       = Calendar.AM;
             } else {
                 this.hour       = value - 12;
                 this.amPm       = Calendar.PM;
             }
             break;
         case Calendar.DATE:
             this.dayOfMonth             = value;
             break;
         case Calendar.MONTH:
             this.month          = value;
             if (this.dayOfMonth > getMaxDaysInMonth())
                 this.dayOfMonth = getMaxDaysInMonth();
             break;
         case Calendar.YEAR:
             this.year           = value;
             break;
         case Calendar.AM_PM:
             this.amPm           = value;
             break;
         }
         computeTime();
     }
 
 
     // Date Arithmetic function.
     public void add(int fieldCode, int amount) {
         switch (fieldCode) {
         case Calendar.DATE:
             amount              *= 24;
         case Calendar.HOUR:
             amount              *= 60;
         case Calendar.MINUTE:
             amount              *= 60;
         case Calendar.SECOND:
             amount              *= 1000;
         case Calendar.MILLISECOND:
             this.date.setTime(this.date.getTime() + amount);
             computeFields();
             break;
         case Calendar.MONTH:
             this.year           += (this.month + amount) / 12;
             this.month          = (this.month + amount) % 12;
             if (this.month < 0) {
                 this.year       -= 1;
                 this.month      += 12;
             }
             if (this.dayOfMonth > getMaxDaysInMonth())
                 this.dayOfMonth = getMaxDaysInMonth();
             computeTime();
             break;
         case Calendar.YEAR:
             this.year           += amount;
             computeTime();
             break;
         }
     }
 
     // Time Field Rolling function.
     public void roll(int fieldCode, int amount) {
         switch (fieldCode) {
         case Calendar.SECOND:
             this.second         = (this.second + amount) % 60;
             if (this.second < 0)
                 this.second     += 60;
             break;
         case Calendar.MINUTE:
             this.minute         = (this.minute + amount) % 60;
             if (this.minute < 0)
                 this.minute     += 60;
             break;
         case Calendar.HOUR:
             this.hour           = (this.hour + amount) % 24;
             if (this.hour < 0)
                 this.hour       += 24;
             break;
         case Calendar.DATE: {
             this.dayOfMonth     = (this.dayOfMonth + amount) % getActualMaximum(Calendar.DATE);
             if (this.dayOfMonth < 0)
                 this.dayOfMonth += getActualMaximum(Calendar.DATE);
             break;
         }
         case Calendar.MONTH: {
             this.month          = (this.month + amount) % 12;
             if (this.month < 0)
                 this.month      += 12;
             if (this.dayOfMonth > getActualMaximum(Calendar.DATE))
                 this.dayOfMonth = getActualMaximum(Calendar.DATE);
             break;
         }
         case Calendar.YEAR:
             this.year           += amount;
             break;
         }
         computeTime();
     }
 
 
     // Compares the time field records.
     public boolean before(GregorianCalendar when) {
             return this.date.before(when.getTime());
     }
     public boolean after(GregorianCalendar when) {
             return this.date.after(when.getTime());
     }
     public boolean equals(GregorianCalendar obj) {
         return this.date.equals(obj.getTime());
     }
 
     public boolean isLeapYear() {
         return isLeapYear(this.year);
     }
     public static boolean isLeapYear(int year) {
         if ((year % 4) == 0    &&    ((year % 100) != 0  ||  (year % 400) == 0))
             return true;
         return false;
     }
 
 
     // Converts the current millisecond time value time to field values in fields[].
     protected  void computeFields() {
         this.second             = this.date.getSeconds();
         this.minute             = this.date.getMinutes();
         this.hour               = this.date.getHours();
         if (this.hour < 12) {
             this.amPm           = Calendar.AM;
         } else {
             this.hour           -= 12;
             this.amPm           = Calendar.PM;
         }
         this.dayOfMonth         = this.date.getDate();
         this.month              = this.date.getMonth();
         this.year               = this.date.getYear() + 1900;
        
     }
     // Converts the current field values in fields[] to the millisecond time value time.
     protected   void computeTime() {
         this.date               = new Date(this.year - 1900, this.month, this.dayOfMonth, this.hour, this.minute, this.second);
     }
 
     // Overrides Cloneable
     public Object clone() {
         GregorianCalendar newCal                = new GregorianCalendar();
         newCal.setTime(this.date);
         return newCal;
     }
 
 } // end of class GregorianCalendar

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.lum.common.client.widgets;
17
18		import java.util.Date;
19
20		/**
21		* <dl>
22		* <dt><b>Title: </b><dd>GregorianCalendar</dd>
23		* <p>
24		* <dt><b>Description: </b><dd>java.util.GregorianCalendar replacment</dd>
25		* </dl>
26		* @author <a href="mailto:andre.freller@gmail.com">Andre Freller</a>
27		* @version $Revision: 0.1 $
28		*/
29		///////// ///////// ///////// ///////// ///////// ///////// ///////// ///////// ///////// ///////// ///////// /////////
30		public class GregorianCalendar extends Calendar
31		{
32		public static final int BC = 0;
33		public static final int AD = 1;
34
35		public GregorianCalendar() {
36	0	super();
37	0	}
38	0	public GregorianCalendar(Date date) {
39	0	setTime(date);
40	0	}
41	0	public GregorianCalendar(int year, int month, int date) {
42	0	set(year, month, date);
43	0	}
44	0	public GregorianCalendar(int year, int month, int date, int hour) {
45	0	set(year, month, date, hour);
46	0	}
47	0	public GregorianCalendar(int year, int month, int date, int hour, int minute) {
48	0	set(year, month, date, hour, minute);
49	0	}
50	0	public GregorianCalendar(int year, int month, int date, int hour, int minute, int second) {
51	0	set(year, month, date, hour, minute, second);
52	0	}
53
54	0	protected static int[] daysInMonth = {31, 28, 31, 30, 31, 30, 31, 31 ,30, 31, 30, 31};
55		public static int getMaxDaysInMonth(int year, int month) {
56	0	if (month == Calendar.FEBRUARY && isLeapYear(year))
57	0	return daysInMonth[month] + 1;
58		else
59	0	return daysInMonth[month];
60		}
61		public int getMaxDaysInMonth() {
62	0	return getMaxDaysInMonth(this.year, this.month);
63		}
64
65		public static int getNumOfWeeksInMonth(int year, int month, int firstDayOfWeek) {
66	0	int day1 = getWeekDay(year, month, 1);
67	0	int maxDays = getMaxDaysInMonth(year, month);
68	0	if (month == Calendar.FEBRUARY && !isLeapYear(year) && day1 == firstDayOfWeek)
69	0	return 4;
70	0	if (maxDays == 30 && (day1 > firstDayOfWeek + 5 \|\| day1 < firstDayOfWeek))
71	0	return 6;
72	0	if (maxDays == 31 && (day1 > firstDayOfWeek + 4 \|\| day1 < firstDayOfWeek))
73	0	return 6;
74	0	return 5;
75		}
76		public int getNumOfWeeksInMonth() {
77	0	return getNumOfWeeksInMonth(this.year, this.month, this.firstWeekDayOfWeek);
78		}
79
80		public static int getWeekDay(int year, int month, int dayOfMonth) {
81	0	int weekDay = year - 1900;
82	0	weekDay += weekDay/4;
83	0	weekDay %= 7;
84	0	if (month <= Calendar.FEBRUARY && isLeapYear(weekDay))
85	0	weekDay -= 1;
86	0	weekDay += dayOfMonth;
87	0	weekDay %= 7;
88	0	if (month == Calendar.MAY)
89	0	weekDay += 1;
90	0	else if (month == Calendar.AUGUST)
91	0	weekDay += 2;
92	0	else if (month == Calendar.FEBRUARY \|\| month == Calendar.MARCH \|\| month == Calendar.NOVEMBER)
93	0	weekDay += 3;
94	0	else if (month == Calendar.JUNE)
95	0	weekDay += 4;
96	0	else if (month == Calendar.SEPTEMBER \|\| month == Calendar.DECEMBER)
97	0	weekDay += 5;
98	0	else if (month == Calendar.APRIL \|\| month == Calendar.JULY)
99	0	weekDay += 6;
100	0	weekDay %= 7;
101
102	0	return Calendar.SUNDAY + weekDay;
103		}
104		public int getWeekDay() {
105	0	return getWeekDay(this.year, this.month, this.dayOfMonth);
106		}
107		public int getFirstWeekDayOfMonth() {
108	0	return getWeekDay(this.year, this.month, 1);
109		}
110
111		// Gets the minimum value for the given time field.
112		public int getMinimum(int fieldCode) {
113	0	switch (fieldCode) {
114		case Calendar.MILLISECOND:
115	0	return 0;
116		case Calendar.SECOND:
117	0	return 0;
118		case Calendar.MINUTE:
119	0	return 0;
120		case Calendar.HOUR:
121	0	return 0;
122		case Calendar.HOUR_OF_DAY:
123	0	return 0;
124		case Calendar.DATE:
125	0	return 1;
126		case Calendar.MONTH:
127	0	return Calendar.JANUARY;
128		default:
129	0	return -1;
130		}
131		}
132		// Return the minimum value that this field could have, given the current date.
133		public int getActualMinimum(int fieldCode) {
134	0	return getMinimum(fieldCode);
135		}
136		// Gets the highest minimum value for the given field if varies.
137		public int getGreatestMinimum(int fieldCode) {
138	0	return getMinimum(fieldCode);
139		}
140
141		// Gets the maximum value for the given time field.
142		public int getMaximum(int fieldCode) {
143	0	switch (fieldCode) {
144		case Calendar.MILLISECOND:
145	0	return 999;
146		case Calendar.SECOND:
147	0	return 59;
148		case Calendar.MINUTE:
149	0	return 59;
150		case Calendar.HOUR:
151	0	return 11;
152		case Calendar.HOUR_OF_DAY:
153	0	return 23;
154		case Calendar.DATE:
155	0	return 31;
156		case Calendar.MONTH:
157	0	return Calendar.DECEMBER;
158		default:
159	0	return -1;
160		}
161		}
162		// Return the maximum value that this field could have, given the current date.
163		public int getActualMaximum(int fieldCode) {
164	0	switch (fieldCode) {
165		case Calendar.MILLISECOND:
166	0	return 999;
167		case Calendar.SECOND:
168	0	return 59;
169		case Calendar.MINUTE:
170	0	return 59;
171		case Calendar.HOUR:
172	0	return 11;
173		case Calendar.HOUR_OF_DAY:
174	0	return 23;
175		case Calendar.DATE:
176	0	return getMaxDaysInMonth();
177		case Calendar.MONTH:
178	0	return Calendar.DECEMBER;
179		default:
180	0	return -1;
181		}
182		}
183		// Gets the lowest maximum value for the given field if varies.
184		public int getLeastMaximum(int fieldCode) {
185	0	switch (fieldCode) {
186		case Calendar.MILLISECOND:
187	0	return 999;
188		case Calendar.SECOND:
189	0	return 59;
190		case Calendar.MINUTE:
191	0	return 59;
192		case Calendar.HOUR:
193	0	return 11;
194		case Calendar.HOUR_OF_DAY:
195	0	return 23;
196		case Calendar.DATE:
197	0	return 28;
198		case Calendar.MONTH:
199	0	return Calendar.DECEMBER;
200		default:
201	0	return -1;
202		}
203		}
204
205
206		public void set(int fieldCode, int value) {
207	0	switch (fieldCode) {
208		case Calendar.SECOND:
209	0	this.second = value;
210	0	break;
211		case Calendar.MINUTE:
212	0	this.minute = value;
213	0	break;
214		case Calendar.HOUR:
215	0	this.hour = value;
216	0	break;
217		case Calendar.HOUR_OF_DAY:
218	0	if (value <= 12) {
219	0	this.hour = value;
220	0	this.amPm = Calendar.AM;
221		} else {
222	0	this.hour = value - 12;
223	0	this.amPm = Calendar.PM;
224		}
225	0	break;
226		case Calendar.DATE:
227	0	this.dayOfMonth = value;
228	0	break;
229		case Calendar.MONTH:
230	0	this.month = value;
231	0	if (this.dayOfMonth > getMaxDaysInMonth())
232	0	this.dayOfMonth = getMaxDaysInMonth();
233		break;
234		case Calendar.YEAR:
235	0	this.year = value;
236	0	break;
237		case Calendar.AM_PM:
238	0	this.amPm = value;
239		break;
240		}
241	0	computeTime();
242	0	}
243
244
245		// Date Arithmetic function.
246		public void add(int fieldCode, int amount) {
247	0	switch (fieldCode) {
248		case Calendar.DATE:
249	0	amount *= 24;
250		case Calendar.HOUR:
251	0	amount *= 60;
252		case Calendar.MINUTE:
253	0	amount *= 60;
254		case Calendar.SECOND:
255	0	amount *= 1000;
256		case Calendar.MILLISECOND:
257	0	this.date.setTime(this.date.getTime() + amount);
258	0	computeFields();
259	0	break;
260		case Calendar.MONTH:
261	0	this.year += (this.month + amount) / 12;
262	0	this.month = (this.month + amount) % 12;
263	0	if (this.month < 0) {
264	0	this.year -= 1;
265	0	this.month += 12;
266		}
267	0	if (this.dayOfMonth > getMaxDaysInMonth())
268	0	this.dayOfMonth = getMaxDaysInMonth();
269	0	computeTime();
270	0	break;
271		case Calendar.YEAR:
272	0	this.year += amount;
273	0	computeTime();
274		break;
275		}
276	0	}
277
278		// Time Field Rolling function.
279		public void roll(int fieldCode, int amount) {
280	0	switch (fieldCode) {
281		case Calendar.SECOND:
282	0	this.second = (this.second + amount) % 60;
283	0	if (this.second < 0)
284	0	this.second += 60;
285		break;
286		case Calendar.MINUTE:
287	0	this.minute = (this.minute + amount) % 60;
288	0	if (this.minute < 0)
289	0	this.minute += 60;
290		break;
291		case Calendar.HOUR:
292	0	this.hour = (this.hour + amount) % 24;
293	0	if (this.hour < 0)
294	0	this.hour += 24;
295		break;
296		case Calendar.DATE: {
297	0	this.dayOfMonth = (this.dayOfMonth + amount) % getActualMaximum(Calendar.DATE);
298	0	if (this.dayOfMonth < 0)
299	0	this.dayOfMonth += getActualMaximum(Calendar.DATE);
300		break;
301		}
302		case Calendar.MONTH: {
303	0	this.month = (this.month + amount) % 12;
304	0	if (this.month < 0)
305	0	this.month += 12;
306	0	if (this.dayOfMonth > getActualMaximum(Calendar.DATE))
307	0	this.dayOfMonth = getActualMaximum(Calendar.DATE);
308		break;
309		}
310		case Calendar.YEAR:
311	0	this.year += amount;
312		break;
313		}
314	0	computeTime();
315	0	}
316
317
318		// Compares the time field records.
319		public boolean before(GregorianCalendar when) {
320	0	return this.date.before(when.getTime());
321		}
322		public boolean after(GregorianCalendar when) {
323	0	return this.date.after(when.getTime());
324		}
325		public boolean equals(GregorianCalendar obj) {
326	0	return this.date.equals(obj.getTime());
327		}
328
329		public boolean isLeapYear() {
330	0	return isLeapYear(this.year);
331		}
332		public static boolean isLeapYear(int year) {
333	0	if ((year % 4) == 0 && ((year % 100) != 0 \|\| (year % 400) == 0))
334	0	return true;
335	0	return false;
336		}
337
338
339		// Converts the current millisecond time value time to field values in fields[].
340		protected void computeFields() {
341	0	this.second = this.date.getSeconds();
342	0	this.minute = this.date.getMinutes();
343	0	this.hour = this.date.getHours();
344	0	if (this.hour < 12) {
345	0	this.amPm = Calendar.AM;
346		} else {
347	0	this.hour -= 12;
348	0	this.amPm = Calendar.PM;
349		}
350	0	this.dayOfMonth = this.date.getDate();
351	0	this.month = this.date.getMonth();
352	0	this.year = this.date.getYear() + 1900;
353
354	0	}
355		// Converts the current field values in fields[] to the millisecond time value time.
356		protected void computeTime() {
357	0	this.date = new Date(this.year - 1900, this.month, this.dayOfMonth, this.hour, this.minute, this.second);
358	0	}
359
360		// Overrides Cloneable
361		public Object clone() {
362	0	GregorianCalendar newCal = new GregorianCalendar();
363	0	newCal.setTime(this.date);
364	0	return newCal;
365		}
366
367		} // end of class GregorianCalendar