KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > joda > time > chrono > BasicWeekyearDateTimeField


1 /*
2  * Copyright 2001-2005 Stephen Colebourne
3  *
4  * Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0
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.joda.time.chrono;
17
18 import org.joda.time.DateTimeConstants;
19 import org.joda.time.DateTimeFieldType;
20 import org.joda.time.DurationField;
21 import org.joda.time.field.FieldUtils;
22 import org.joda.time.field.ImpreciseDateTimeField;
23
24 /**
25  * Provides time calculations for the week of the weekyear component of time.
26  *
27  * @author Guy Allard
28  * @author Stephen Colebourne
29  * @author Brian S O'Neill
30  * @since 1.1, refactored from GJWeekyearDateTimeField
31  */
32 final class BasicWeekyearDateTimeField extends ImpreciseDateTimeField {
33     
34     private static final long serialVersionUID = 6215066916806820644L;
35
36     private static final long WEEK_53 = (53L - 1) * DateTimeConstants.MILLIS_PER_WEEK;
37
38     private final BasicChronology iChronology;
39
40     /**
41      * Restricted constructor
42      */
43     BasicWeekyearDateTimeField(BasicChronology chronology) {
44         super(DateTimeFieldType.weekyear(), chronology.getAverageMillisPerYear());
45         iChronology = chronology;
46     }
47
48     public boolean isLenient() {
49         return false;
50     }
51
52     /**
53      * Get the Year of a week based year component of the specified time instant.
54      *
55      * @see org.joda.time.DateTimeField#get
56      * @param instant the time instant in millis to query.
57      * @return the year extracted from the input.
58      */
59     public int get(long instant) {
60         return iChronology.getWeekyear(instant);
61     }
62
63     /**
64      * Add the specified years to the specified time instant.
65      *
66      * @see org.joda.time.DateTimeField#add
67      * @param instant the time instant in millis to update.
68      * @param years the years to add (can be negative).
69      * @return the updated time instant.
70      */
71     public long add(long instant, int years) {
72         if (years == 0) {
73             return instant;
74         }
75         return set(instant, get(instant) + years);
76     }
77
78     public long add(long instant, long value) {
79         return add(instant, FieldUtils.safeToInt(value));
80     }
81
82     /**
83      * Add to the year component of the specified time instant
84      * wrapping around within that component if necessary.
85      *
86      * @see org.joda.time.DateTimeField#addWrapField
87      * @param instant the time instant in millis to update.
88      * @param years the years to add (can be negative).
89      * @return the updated time instant.
90      */
91     public long addWrapField(long instant, int years) {
92         return add(instant, years);
93     }
94
95     public long getDifferenceAsLong(long minuendInstant, long subtrahendInstant) {
96         if (minuendInstant < subtrahendInstant) {
97             return -getDifference(subtrahendInstant, minuendInstant);
98         }
99
100         int minuendWeekyear = get(minuendInstant);
101         int subtrahendWeekyear = get(subtrahendInstant);
102
103         long minuendRem = remainder(minuendInstant);
104         long subtrahendRem = remainder(subtrahendInstant);
105
106         // Balance leap weekyear differences on remainders.
107 if (subtrahendRem >= WEEK_53 && iChronology.getWeeksInYear(minuendWeekyear) <= 52) {
108             subtrahendRem -= DateTimeConstants.MILLIS_PER_WEEK;
109         }
110
111         int difference = minuendWeekyear - subtrahendWeekyear;
112         if (minuendRem < subtrahendRem) {
113             difference--;
114         }
115         return difference;
116     }
117
118     /**
119      * Set the Year of a week based year component of the specified time instant.
120      *
121      * @see org.joda.time.DateTimeField#set
122      * @param instant the time instant in millis to update.
123      * @param year the year (-9999,9999) to set the date to.
124      * @return the updated DateTime.
125      * @throws IllegalArgumentException if year is invalid.
126      */
127     public long set(long instant, int year) {
128         FieldUtils.verifyValueBounds(this, Math.abs(year),
129                                      iChronology.getMinYear(), iChronology.getMaxYear());
130         //
131 // Do nothing if no real change is requested.
132 //
133 int thisWeekyear = get( instant );
134         if ( thisWeekyear == year ) {
135             return instant;
136         }
137         //
138 // Calculate the DayOfWeek (to be preserved).
139 //
140 int thisDow = iChronology.getDayOfWeek(instant);
141         //
142 // Calculate the maximum weeks in the target year.
143 //
144 int weeksInFromYear = iChronology.getWeeksInYear( thisWeekyear );
145         int weeksInToYear = iChronology.getWeeksInYear( year );
146         int maxOutWeeks = (weeksInToYear < weeksInFromYear) ?
147             weeksInToYear : weeksInFromYear;
148         //
149 // Get the current week of the year. This will be preserved in
150 // the output unless it is greater than the maximum possible
151 // for the target weekyear. In that case it is adjusted
152 // to the maximum possible.
153 //
154 int setToWeek = iChronology.getWeekOfWeekyear(instant);
155         if ( setToWeek > maxOutWeeks ) {
156             setToWeek = maxOutWeeks;
157         }
158         //
159 // Get a wroking copy of the current date-time.
160 // This can be a convenience for debugging.
161 //
162 long workInstant = instant; // Get a copy
163 //
164 // Attempt to get close to the proper weekyear.
165 // Note - we cannot currently call ourself, so we just call
166 // set for the year. This at least gets us close.
167 //
168 workInstant = iChronology.setYear( workInstant, year );
169         //
170 // Calculate the weekyear number for the get close to value
171 // (which might not be equal to the year just set).
172 //
173 int workWoyYear = get( workInstant );
174
175         //
176 // At most we are off by one year, which can be "fixed" by
177 // adding/subtracting a week.
178 //
179 if ( workWoyYear < year ) {
180             workInstant += DateTimeConstants.MILLIS_PER_WEEK;
181         } else if ( workWoyYear > year ) {
182             workInstant -= DateTimeConstants.MILLIS_PER_WEEK;
183         }
184         //
185 // Set the proper week in the current weekyear.
186 //
187
188         // BEGIN: possible set WeekOfWeekyear logic.
189 int currentWoyWeek = iChronology.getWeekOfWeekyear(workInstant);
190         // No range check required (we already know it is OK).
191 workInstant = workInstant + (setToWeek - currentWoyWeek)
192             * (long)DateTimeConstants.MILLIS_PER_WEEK;
193         // END: possible set WeekOfWeekyear logic.
194
195         //
196 // Reset DayOfWeek to previous value.
197 //
198 // Note: This works fine, but it ideally shouldn't invoke other
199 // fields from within a field.
200 workInstant = iChronology.dayOfWeek().set( workInstant, thisDow );
201         //
202 // Return result.
203 //
204 return workInstant;
205     }
206
207     public DurationField getRangeDurationField() {
208         return null;
209     }
210
211     public boolean isLeap(long instant) {
212         return iChronology.getWeeksInYear(iChronology.getWeekyear(instant)) > 52;
213     }
214
215     public int getLeapAmount(long instant) {
216         return iChronology.getWeeksInYear(iChronology.getWeekyear(instant)) - 52;
217     }
218
219     public DurationField getLeapDurationField() {
220         return iChronology.weeks();
221     }
222
223     public int getMinimumValue() {
224         return iChronology.getMinYear();
225     }
226
227     public int getMaximumValue() {
228         return iChronology.getMaxYear();
229     }
230
231     public long roundFloor(long instant) {
232         // Note: This works fine, but it ideally shouldn't invoke other
233 // fields from within a field.
234 instant = iChronology.weekOfWeekyear().roundFloor(instant);
235         int wow = iChronology.getWeekOfWeekyear(instant);
236         if (wow > 1) {
237             instant -= ((long) DateTimeConstants.MILLIS_PER_WEEK) * (wow - 1);
238         }
239         return instant;
240     }
241
242     public long remainder(long instant) {
243         return instant - roundFloor(instant);
244     }
245
246     /**
247      * Serialization singleton
248      */
249     private Object JavaDoc readResolve() {
250         return iChronology.weekyear();
251     }
252 }
253
Popular Tags