EMMA Coverage Report (generated Wed Jun 28 22:15:27 PDT 2006)
[all classes][org.apache.derby.iapi.util]

COVERAGE SUMMARY FOR SOURCE FILE [CheapDateFormatter.java]

nameclass, %method, %block, %line, %
CheapDateFormatter.java100% (1/1)80%  (4/5)83%  (247/296)74%  (35.4/48)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class CheapDateFormatter100% (1/1)80%  (4/5)83%  (247/296)74%  (35.4/48)
<static initializer> 100% (1/1)100% (52/52)100% (1/1)
CheapDateFormatter (): void 0%   (0/1)0%   (0/3)0%   (0/1)
formatDate (long): String 100% (1/1)76%  (143/189)68%  (24.4/36)
threeDigits (long): String 100% (1/1)100% (33/33)100% (6/6)
twoDigits (long): String 100% (1/1)100% (19/19)100% (4/4)

1/*
2 
3   Derby - Class org.apache.derby.iapi.util.CheapDateFormatter
4 
5   Copyright 2000, 2004 The Apache Software Foundation or its licensors, as applicable.
6 
7   Licensed under the Apache License, Version 2.0 (the "License");
8   you may not use this file except in compliance with the License.
9   You may obtain a copy of the License at
10 
11      http://www.apache.org/licenses/LICENSE-2.0
12 
13   Unless required by applicable law or agreed to in writing, software
14   distributed under the License is distributed on an "AS IS" BASIS,
15   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   See the License for the specific language governing permissions and
17   limitations under the License.
18 
19 */
20 
21package org.apache.derby.iapi.util;
22 
23/**
24 * This class contains static methods for formatting dates into Strings.
25 * It can be used where standard Date formatting is judged to be too
26 * expensive.
27 */
28public class CheapDateFormatter {
29        static final long SECONDS  = 1000L;
30        static final long MINUTES = SECONDS * 60L;
31        static final long HOURS = MINUTES * 60L;
32        static final long DAYS = HOURS * 24L;
33        static final long NORMAL_YEAR = DAYS * 365L;
34        static final long LEAP_YEAR = NORMAL_YEAR + DAYS;
35        static final long FOURYEARS = (NORMAL_YEAR * 3L) + LEAP_YEAR;
36        static final long END_OF_FIRST_YEAR = NORMAL_YEAR;
37        static final long END_OF_SECOND_YEAR = END_OF_FIRST_YEAR + LEAP_YEAR;
38        static final long END_OF_THIRD_YEAR = END_OF_SECOND_YEAR + NORMAL_YEAR;
39        static final int[] DAYS_IN_MONTH = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
40        static final int FEBRUARY = 1;
41 
42        /**
43         * This method formats the current date into a String. The input is
44         * a long representing the number of milliseconds since Jan. 1, 1970.
45         * The output is a String in the form yyyy/mm/dd hh:mm:ss.ddd GMT.
46         *
47         * The purpose of this class is to format date strings without paying
48         * the price of instantiating ResourceBundles and Locales, which the
49         * java.util.Date class does whenever you format a date string.
50         * As a result, the output of this class is not localized, it does
51         * not take the local time zone into account, and it is possible that
52         * it will not be as accurate as the standard Date class. It is OK
53         * to use this method when, for example, formatting timestamps to
54         * write to db2j.LOG, but not for manipulating dates in language
55         * processing.
56         *
57         * @param time        The current time in milliseconds since Jan. 1, 1970
58         *
59         * @return The date formatted as yyyy/mm/dd hh:mm:ss.ddd GMT.
60         */
61        public static String formatDate(long time) {
62                // Assume not a leap year until we know otherwise
63                boolean leapYear = false;
64 
65                // How many four year periods since Jan. 1, 1970?
66                long year = ((time / FOURYEARS) * 4L);
67 
68                // How much time is left over after the four-year periods?
69                long leftover = time % FOURYEARS;
70                time -= (year / 4L) * FOURYEARS;
71 
72                year += 1970L;
73 
74                // Does time extend past end of first year in four-year period?
75                if (leftover >= END_OF_FIRST_YEAR) {
76                        year++;
77                        time -= NORMAL_YEAR;
78                }
79 
80                // Does time extend past end of second year in four-year period?
81                if (leftover >= END_OF_SECOND_YEAR) {
82                        year++;
83                        time -= NORMAL_YEAR;
84                }
85 
86                // Does time extend past end of third year in four-year period?
87                if (leftover >= END_OF_THIRD_YEAR) {
88                        year++;
89                        time -= LEAP_YEAR;
90                }
91 
92                // It's a leap year if divisible by 4, unless divisible by 100,
93                // unless divisible by 400.
94                if ((year % 4L) == 0) {
95                        if ((year % 100L) == 0) {
96                                if ((year % 400L) == 0) {
97                                        leapYear = true;
98                                }
99                        }
100                        leapYear = true;
101                }
102 
103                // What day of the year is this, starting at 1?
104                long days = (time / DAYS) + 1;
105 
106                // What month is this, starting at 1?
107                int month = 1;
108                for (int i = 0; i < DAYS_IN_MONTH.length; i++) {
109                        int daysInMonth;
110 
111                        if (leapYear && (i == FEBRUARY)) {
112                                // February has 29 days in a leap year
113                                daysInMonth = 29;
114                        } else {
115                                // Get number of days in next month
116                                daysInMonth = DAYS_IN_MONTH[i];
117                        }
118 
119                        // Is date after the month we are looking at?
120                        if (days > daysInMonth) {
121                                // Count number of months
122                                month++;
123 
124                                // Subtract number of days in month
125                                days -= daysInMonth;
126                        } else {
127                                // Don't bother to look any more - the date is within
128                                // the current month.
129                                break;
130                        }
131                }
132 
133                // How much time is left after days are accounted for?
134                time %= DAYS;
135 
136                long hours = time / HOURS;
137 
138                // How much time is left after hours are accounted for?
139                time %= HOURS;
140 
141                long minutes = time / MINUTES;
142 
143                // How much time is left after minutes are accounted for?
144                time %= MINUTES;
145 
146                long seconds = time / SECONDS;
147 
148                // How much time is left after seconds are accounted for?
149                time %= SECONDS;
150 
151                return year + "-" +
152                                twoDigits(month) + "-" +
153                                twoDigits(days) + " " +
154                                twoDigits(hours) + ":" +
155                                twoDigits(minutes) + ":" +
156                                twoDigits(seconds) + "." +
157                                threeDigits(time) + " GMT";
158        }
159 
160        private static String twoDigits(long val) {
161                String retval;
162 
163                if (val < 10) {
164                        retval = "0" + val;
165                } else {
166                        retval = Long.toString(val);
167                }
168 
169                return retval;
170        }
171 
172        private static String threeDigits(long val) {
173                String retval;
174 
175                if (val < 10) {
176                        retval = "00" + val;
177                } else if (val < 100) {
178                        retval = "0" + val;
179                } else {
180                        retval = Long.toString(val);
181                }
182 
183                return retval;
184        }
185}

[all classes][org.apache.derby.iapi.util]
EMMA 2.0.5312 (C) Vladimir Roubtsov