KickJava   Java API By Example, From Geeks To Geeks.

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


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.Chronology;
19 import org.joda.time.DateTimeField;
20 import org.joda.time.DateTimeZone;
21 import org.joda.time.field.LenientDateTimeField;
22
23 /**
24  * Wraps another Chronology, ensuring all the fields are lenient.
25  * <p>
26  * LenientChronology is thread-safe and immutable.
27  *
28  * @author Brian S O'Neill
29  * @since 1.0
30  * @see LenientDateTimeField
31  * @see StrictChronology
32  */
33 public final class LenientChronology extends AssembledChronology {
34
35     /** Serialization lock */
36     private static final long serialVersionUID = -3148237568046877177L;
37
38     /**
39      * Create a LenientChronology for any chronology.
40      *
41      * @param base the chronology to wrap
42      * @throws IllegalArgumentException if chronology is null
43      */
44     public static LenientChronology getInstance(Chronology base) {
45         if (base == null) {
46             throw new IllegalArgumentException JavaDoc("Must supply a chronology");
47         }
48         return new LenientChronology(base);
49     }
50
51     private transient Chronology iWithUTC;
52
53     /**
54      * Create a LenientChronology for any chronology.
55      *
56      * @param base the chronology to wrap
57      */
58     private LenientChronology(Chronology base) {
59         super(base, null);
60     }
61
62     public Chronology withUTC() {
63         if (iWithUTC == null) {
64             if (getZone() == DateTimeZone.UTC) {
65                 iWithUTC = this;
66             } else {
67                 iWithUTC = LenientChronology.getInstance(getBase().withUTC());
68             }
69         }
70         return iWithUTC;
71     }
72
73     public Chronology withZone(DateTimeZone zone) {
74         if (zone == null) {
75             zone = DateTimeZone.getDefault();
76         }
77         if (zone == DateTimeZone.UTC) {
78             return withUTC();
79         }
80         if (zone == getZone()) {
81             return this;
82         }
83         return LenientChronology.getInstance(getBase().withZone(zone));
84     }
85
86     protected void assemble(Fields fields) {
87         fields.year = convertField(fields.year);
88         fields.yearOfEra = convertField(fields.yearOfEra);
89         fields.yearOfCentury = convertField(fields.yearOfCentury);
90         fields.centuryOfEra = convertField(fields.centuryOfEra);
91         fields.era = convertField(fields.era);
92         fields.dayOfWeek = convertField(fields.dayOfWeek);
93         fields.dayOfMonth = convertField(fields.dayOfMonth);
94         fields.dayOfYear = convertField(fields.dayOfYear);
95         fields.monthOfYear = convertField(fields.monthOfYear);
96         fields.weekOfWeekyear = convertField(fields.weekOfWeekyear);
97         fields.weekyear = convertField(fields.weekyear);
98         fields.weekyearOfCentury = convertField(fields.weekyearOfCentury);
99
100         fields.millisOfSecond = convertField(fields.millisOfSecond);
101         fields.millisOfDay = convertField(fields.millisOfDay);
102         fields.secondOfMinute = convertField(fields.secondOfMinute);
103         fields.secondOfDay = convertField(fields.secondOfDay);
104         fields.minuteOfHour = convertField(fields.minuteOfHour);
105         fields.minuteOfDay = convertField(fields.minuteOfDay);
106         fields.hourOfDay = convertField(fields.hourOfDay);
107         fields.hourOfHalfday = convertField(fields.hourOfHalfday);
108         fields.clockhourOfDay = convertField(fields.clockhourOfDay);
109         fields.clockhourOfHalfday = convertField(fields.clockhourOfHalfday);
110         fields.halfdayOfDay = convertField(fields.halfdayOfDay);
111     }
112
113     private static final DateTimeField convertField(DateTimeField field) {
114         return LenientDateTimeField.getInstance(field);
115     }
116
117     //-----------------------------------------------------------------------
118 /**
119      * A lenient chronology is only equal to a lenient chronology with the
120      * same base chronology.
121      *
122      * @param obj the object to compare to
123      * @return true if equal
124      * @since 1.4
125      */
126     public boolean equals(Object JavaDoc obj) {
127         if (this == obj) {
128             return true;
129         }
130         if (obj instanceof LenientChronology == false) {
131             return false;
132         }
133         LenientChronology chrono = (LenientChronology) obj;
134         return getBase().equals(chrono.getBase());
135     }
136
137     /**
138      * A suitable hashcode for the chronology.
139      *
140      * @return the hashcode
141      * @since 1.4
142      */
143     public int hashCode() {
144         return 236548278 + getBase().hashCode() * 7;
145     }
146
147     /**
148      * A debugging string for the chronology.
149      *
150      * @return the debugging string
151      */
152     public String JavaDoc toString() {
153         return "LenientChronology[" + getBase().toString() + ']';
154     }
155
156 }
157
Popular Tags