001/*
002 *  Copyright 2001-2009 Stephen Colebourne
003 *
004 *  Licensed under the Apache License, Version 2.0 (the "License");
005 *  you may not use this file except in compliance with the License.
006 *  You may obtain a copy of the License at
007 *
008 *      http://www.apache.org/licenses/LICENSE-2.0
009 *
010 *  Unless required by applicable law or agreed to in writing, software
011 *  distributed under the License is distributed on an "AS IS" BASIS,
012 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 *  See the License for the specific language governing permissions and
014 *  limitations under the License.
015 */
016package org.joda.time.chrono;
017
018import java.util.HashMap;
019import java.util.Map;
020
021import org.joda.time.Chronology;
022import org.joda.time.DateTime;
023import org.joda.time.DateTimeConstants;
024import org.joda.time.DateTimeField;
025import org.joda.time.DateTimeFieldType;
026import org.joda.time.DateTimeZone;
027import org.joda.time.field.DelegatedDateTimeField;
028import org.joda.time.field.DividedDateTimeField;
029import org.joda.time.field.OffsetDateTimeField;
030import org.joda.time.field.RemainderDateTimeField;
031import org.joda.time.field.SkipUndoDateTimeField;
032
033/**
034 * A chronology that matches the BuddhistCalendar class supplied by Sun.
035 * <p>
036 * The chronology is identical to the Gregorian/Julian, except that the
037 * year is offset by +543 and the era is named 'BE' for Buddhist Era.
038 * <p>
039 * This class was intended by Sun to model the calendar used in Thailand.
040 * However, the actual rules for Thailand are much more involved than
041 * this class covers. (This class is accurate after 1941-01-01 ISO).
042 * <p>
043 * This chronlogy is being retained for those who want a same effect
044 * replacement for the Sun class. It is hoped that community support will
045 * enable a more accurate chronology for Thailand, to be developed.
046 * <p>
047 * BuddhistChronology is thread-safe and immutable.
048 *
049 * @author Stephen Colebourne
050 * @author Brian S O'Neill
051 * @since 1.0
052 */
053public final class BuddhistChronology extends AssembledChronology {
054    
055    /** Serialization lock */
056    private static final long serialVersionUID = -3474595157769370126L;
057
058    /**
059     * Constant value for 'Buddhist Era', equivalent to the value returned
060     * for AD/CE. Note that this differs from the constant in BuddhistCalendar.
061     */
062    public static final int BE = DateTimeConstants.CE;
063
064    /** A singleton era field. */
065    private static final DateTimeField ERA_FIELD = new BasicSingleEraDateTimeField("BE");
066
067    /** Number of years difference in calendars. */
068    private static final int BUDDHIST_OFFSET = 543;
069
070    /** Cache of zone to chronology */
071    private static final Map<DateTimeZone, BuddhistChronology> cCache = new HashMap<DateTimeZone, BuddhistChronology>();
072
073    /** UTC instance of the chronology */
074    private static final BuddhistChronology INSTANCE_UTC = getInstance(DateTimeZone.UTC);
075
076    /**
077     * Standard instance of a Buddhist Chronology, that matches
078     * Sun's BuddhistCalendar class. This means that it follows the
079     * GregorianJulian calendar rules with a cutover date.
080     * <p>
081     * The time zone of the returned instance is UTC.
082     */
083    public static BuddhistChronology getInstanceUTC() {
084        return INSTANCE_UTC;
085    }
086
087    /**
088     * Standard instance of a Buddhist Chronology, that matches
089     * Sun's BuddhistCalendar class. This means that it follows the
090     * GregorianJulian calendar rules with a cutover date.
091     */
092    public static BuddhistChronology getInstance() {
093        return getInstance(DateTimeZone.getDefault());
094    }
095
096    /**
097     * Standard instance of a Buddhist Chronology, that matches
098     * Sun's BuddhistCalendar class. This means that it follows the
099     * GregorianJulian calendar rules with a cutover date.
100     *
101     * @param zone  the time zone to use, null is default
102     */
103    public static synchronized BuddhistChronology getInstance(DateTimeZone zone) {
104        if (zone == null) {
105            zone = DateTimeZone.getDefault();
106        }
107        BuddhistChronology chrono = cCache.get(zone);
108        if (chrono == null) {
109            // First create without a lower limit.
110            chrono = new BuddhistChronology(GJChronology.getInstance(zone, null), null);
111            // Impose lower limit and make another BuddhistChronology.
112            DateTime lowerLimit = new DateTime(1, 1, 1, 0, 0, 0, 0, chrono);
113            chrono = new BuddhistChronology(LimitChronology.getInstance(chrono, lowerLimit, null), "");
114            cCache.put(zone, chrono);
115        }
116        return chrono;
117    }
118
119    // Constructors and instance variables
120    //-----------------------------------------------------------------------
121    
122    /**
123     * Restricted constructor.
124     *
125     * @param param if non-null, then don't change the field set
126     */
127    private BuddhistChronology(Chronology base, Object param) {
128        super(base, param);
129    }
130
131    /**
132     * Serialization singleton
133     */
134    private Object readResolve() {
135        Chronology base = getBase();
136        return base == null ? getInstanceUTC() : getInstance(base.getZone());
137    }
138
139    // Conversion
140    //-----------------------------------------------------------------------
141    /**
142     * Gets the Chronology in the UTC time zone.
143     * 
144     * @return the chronology in UTC
145     */
146    public Chronology withUTC() {
147        return INSTANCE_UTC;
148    }
149
150    /**
151     * Gets the Chronology in a specific time zone.
152     * 
153     * @param zone  the zone to get the chronology in, null is default
154     * @return the chronology
155     */
156    public Chronology withZone(DateTimeZone zone) {
157        if (zone == null) {
158            zone = DateTimeZone.getDefault();
159        }
160        if (zone == getZone()) {
161            return this;
162        }
163        return getInstance(zone);
164    }
165
166    /**
167     * Checks if this chronology instance equals another.
168     * 
169     * @param obj  the object to compare to
170     * @return true if equal
171     * @since 1.6
172     */
173    public boolean equals(Object obj) {
174        return super.equals(obj);
175    }
176
177    /**
178     * A suitable hash code for the chronology.
179     * 
180     * @return the hash code
181     * @since 1.6
182     */
183    public int hashCode() {
184        return "Buddhist".hashCode() * 11 + getZone().hashCode();
185    }
186
187    // Output
188    //-----------------------------------------------------------------------
189    /**
190     * Gets a debugging toString.
191     * 
192     * @return a debugging string
193     */
194    public String toString() {
195        String str = "BuddhistChronology";
196        DateTimeZone zone = getZone();
197        if (zone != null) {
198            str = str + '[' + zone.getID() + ']';
199        }
200        return str;
201    }
202
203    protected void assemble(Fields fields) {
204        if (getParam() == null) {
205            // julian chrono removed zero, but we need to put it back
206            DateTimeField field = fields.year;
207            fields.year = new OffsetDateTimeField(
208                    new SkipUndoDateTimeField(this, field), BUDDHIST_OFFSET);
209            
210            // one era, so yearOfEra is the same
211            field = fields.yearOfEra;
212            fields.yearOfEra = new DelegatedDateTimeField(
213                fields.year, DateTimeFieldType.yearOfEra());
214            
215            // julian chrono removed zero, but we need to put it back
216            field = fields.weekyear;
217            fields.weekyear = new OffsetDateTimeField(
218                    new SkipUndoDateTimeField(this, field), BUDDHIST_OFFSET);
219            
220            field = new OffsetDateTimeField(fields.yearOfEra, 99);
221            fields.centuryOfEra = new DividedDateTimeField(
222                field, DateTimeFieldType.centuryOfEra(), 100);
223            
224            field = new RemainderDateTimeField(
225                (DividedDateTimeField) fields.centuryOfEra);
226            fields.yearOfCentury = new OffsetDateTimeField(
227                field, DateTimeFieldType.yearOfCentury(), 1);
228            
229            field = new RemainderDateTimeField(
230                fields.weekyear, DateTimeFieldType.weekyearOfCentury(), 100);
231            fields.weekyearOfCentury = new OffsetDateTimeField(
232                field, DateTimeFieldType.weekyearOfCentury(), 1);
233            
234            fields.era = ERA_FIELD;
235        }
236    }
237   
238}