KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > joda > time > field > UnsupportedDateTimeField


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.field;
17
18 import java.io.Serializable JavaDoc;
19 import java.util.HashMap JavaDoc;
20 import java.util.Locale JavaDoc;
21 import org.joda.time.DateTimeField;
22 import org.joda.time.DateTimeFieldType;
23 import org.joda.time.DurationField;
24 import org.joda.time.ReadablePartial;
25
26 /**
27  * A placeholder implementation to use when a datetime field is not supported.
28  * <p>
29  * UnsupportedDateTimeField is thread-safe and immutable.
30  *
31  * @author Brian S O'Neill
32  * @since 1.0
33  */

34 public final class UnsupportedDateTimeField extends DateTimeField implements Serializable JavaDoc {
35
36     /** Serialilzation version */
37     private static final long serialVersionUID = -1934618396111902255L;
38
39     /** The cache of unsupported datetime field instances */
40     private static HashMap JavaDoc cCache;
41
42     /**
43      * Gets an instance of UnsupportedDateTimeField for a specific named field.
44      * Names should be of standard format, such as 'monthOfYear' or 'hourOfDay'.
45      * The returned instance is cached.
46      *
47      * @param type the type to obtain
48      * @return the instance
49      * @throws IllegalArgumentException if durationField is null
50      */

51     public static synchronized UnsupportedDateTimeField getInstance(
52             DateTimeFieldType type, DurationField durationField) {
53
54         UnsupportedDateTimeField field;
55         if (cCache == null) {
56             cCache = new HashMap JavaDoc(7);
57             field = null;
58         } else {
59             field = (UnsupportedDateTimeField)cCache.get(type);
60             if (field != null && field.getDurationField() != durationField) {
61                 field = null;
62             }
63         }
64         if (field == null) {
65             field = new UnsupportedDateTimeField(type, durationField);
66             cCache.put(type, field);
67         }
68         return field;
69     }
70
71     /** The field type */
72     private final DateTimeFieldType iType;
73     /** The duration of the datetime field */
74     private final DurationField iDurationField;
75
76     /**
77      * Constructor.
78      *
79      * @param type the field type
80      * @param durationField the duration to use
81      */

82     private UnsupportedDateTimeField(DateTimeFieldType type, DurationField durationField) {
83         if (type == null || durationField == null) {
84             throw new IllegalArgumentException JavaDoc();
85         }
86         iType = type;
87         iDurationField = durationField;
88     }
89
90     //-----------------------------------------------------------------------
91
// Design note: Simple accessors return a suitable value, but methods
92
// intended to perform calculations throw an UnsupportedOperationException.
93

94     public DateTimeFieldType getType() {
95         return iType;
96     }
97
98     public String JavaDoc getName() {
99         return iType.getName();
100     }
101
102     /**
103      * This field is not supported.
104      *
105      * @return false always
106      */

107     public boolean isSupported() {
108         return false;
109     }
110
111     /**
112      * This field is not lenient.
113      *
114      * @return false always
115      */

116     public boolean isLenient() {
117         return false;
118     }
119
120     /**
121      * Always throws UnsupportedOperationException
122      *
123      * @throws UnsupportedOperationException
124      */

125     public int get(long instant) {
126         throw unsupported();
127     }
128
129     /**
130      * Always throws UnsupportedOperationException
131      *
132      * @throws UnsupportedOperationException
133      */

134     public String JavaDoc getAsText(long instant, Locale JavaDoc locale) {
135         throw unsupported();
136     }
137
138     /**
139      * Always throws UnsupportedOperationException
140      *
141      * @throws UnsupportedOperationException
142      */

143     public String JavaDoc getAsText(long instant) {
144         throw unsupported();
145     }
146
147     /**
148      * Always throws UnsupportedOperationException
149      *
150      * @throws UnsupportedOperationException
151      */

152     public String JavaDoc getAsText(ReadablePartial partial, int fieldValue, Locale JavaDoc locale) {
153         throw unsupported();
154     }
155
156     /**
157      * Always throws UnsupportedOperationException
158      *
159      * @throws UnsupportedOperationException
160      */

161     public String JavaDoc getAsText(ReadablePartial partial, Locale JavaDoc locale) {
162         throw unsupported();
163     }
164
165     /**
166      * Always throws UnsupportedOperationException
167      *
168      * @throws UnsupportedOperationException
169      */

170     public String JavaDoc getAsText(int fieldValue, Locale JavaDoc locale) {
171         throw unsupported();
172     }
173
174     /**
175      * Always throws UnsupportedOperationException
176      *
177      * @throws UnsupportedOperationException
178      */

179     public String JavaDoc getAsShortText(long instant, Locale JavaDoc locale) {
180         throw unsupported();
181     }
182
183     /**
184      * Always throws UnsupportedOperationException
185      *
186      * @throws UnsupportedOperationException
187      */

188     public String JavaDoc getAsShortText(long instant) {
189         throw unsupported();
190     }
191
192     /**
193      * Always throws UnsupportedOperationException
194      *
195      * @throws UnsupportedOperationException
196      */

197     public String JavaDoc getAsShortText(ReadablePartial partial, int fieldValue, Locale JavaDoc locale) {
198         throw unsupported();
199     }
200
201     /**
202      * Always throws UnsupportedOperationException
203      *
204      * @throws UnsupportedOperationException
205      */

206     public String JavaDoc getAsShortText(ReadablePartial partial, Locale JavaDoc locale) {
207         throw unsupported();
208     }
209
210     /**
211      * Always throws UnsupportedOperationException
212      *
213      * @throws UnsupportedOperationException
214      */

215     public String JavaDoc getAsShortText(int fieldValue, Locale JavaDoc locale) {
216         throw unsupported();
217     }
218
219     /**
220      * Delegates to the duration field.
221      *
222      * @throws UnsupportedOperationException if the duration is unsupported
223      */

224     public long add(long instant, int value) {
225         return getDurationField().add(instant, value);
226     }
227
228     /**
229      * Delegates to the duration field.
230      *
231      * @throws UnsupportedOperationException if the duration is unsupported
232      */

233     public long add(long instant, long value) {
234         return getDurationField().add(instant, value);
235     }
236
237     /**
238      * Always throws UnsupportedOperationException
239      *
240      * @throws UnsupportedOperationException
241      */

242     public int[] add(ReadablePartial instant, int fieldIndex, int[] values, int valueToAdd) {
243         throw unsupported();
244     }
245
246     /**
247      * Always throws UnsupportedOperationException
248      *
249      * @throws UnsupportedOperationException
250      */

251     public int[] addWrapPartial(ReadablePartial instant, int fieldIndex, int[] values, int valueToAdd) {
252         throw unsupported();
253     }
254
255     /**
256      * Always throws UnsupportedOperationException
257      *
258      * @throws UnsupportedOperationException
259      */

260     public long addWrapField(long instant, int value) {
261         throw unsupported();
262     }
263
264     /**
265      * Always throws UnsupportedOperationException
266      *
267      * @throws UnsupportedOperationException
268      */

269     public int[] addWrapField(ReadablePartial instant, int fieldIndex, int[] values, int valueToAdd) {
270         throw unsupported();
271     }
272
273     /**
274      * Delegates to the duration field.
275      *
276      * @throws UnsupportedOperationException if the duration is unsupported
277      */

278     public int getDifference(long minuendInstant, long subtrahendInstant) {
279         return getDurationField().getDifference(minuendInstant, subtrahendInstant);
280     }
281
282     /**
283      * Delegates to the duration field.
284      *
285      * @throws UnsupportedOperationException if the duration is unsupported
286      */

287     public long getDifferenceAsLong(long minuendInstant, long subtrahendInstant) {
288         return getDurationField().getDifferenceAsLong(minuendInstant, subtrahendInstant);
289     }
290
291     /**
292      * Always throws UnsupportedOperationException
293      *
294      * @throws UnsupportedOperationException
295      */

296     public long set(long instant, int value) {
297         throw unsupported();
298     }
299
300     /**
301      * Always throws UnsupportedOperationException
302      *
303      * @throws UnsupportedOperationException
304      */

305     public int[] set(ReadablePartial instant, int fieldIndex, int[] values, int newValue) {
306         throw unsupported();
307     }
308
309     /**
310      * Always throws UnsupportedOperationException
311      *
312      * @throws UnsupportedOperationException
313      */

314     public long set(long instant, String JavaDoc text, Locale JavaDoc locale) {
315         throw unsupported();
316     }
317
318     /**
319      * Always throws UnsupportedOperationException
320      *
321      * @throws UnsupportedOperationException
322      */

323     public long set(long instant, String JavaDoc text) {
324         throw unsupported();
325     }
326
327     /**
328      * Always throws UnsupportedOperationException
329      *
330      * @throws UnsupportedOperationException
331      */

332     public int[] set(ReadablePartial instant, int fieldIndex, int[] values, String JavaDoc text, Locale JavaDoc locale) {
333         throw unsupported();
334     }
335
336     /**
337      * Even though this DateTimeField is unsupported, the duration field might
338      * be supported.
339      *
340      * @return a possibly supported DurationField
341      */

342     public DurationField getDurationField() {
343         return iDurationField;
344     }
345
346     /**
347      * Always returns null.
348      *
349      * @return null always
350      */

351     public DurationField getRangeDurationField() {
352         return null;
353     }
354
355     /**
356      * Always throws UnsupportedOperationException
357      *
358      * @throws UnsupportedOperationException
359      */

360     public boolean isLeap(long instant) {
361         throw unsupported();
362     }
363
364     /**
365      * Always throws UnsupportedOperationException
366      *
367      * @throws UnsupportedOperationException
368      */

369     public int getLeapAmount(long instant) {
370         throw unsupported();
371     }
372
373     /**
374      * Always returns null.
375      *
376      * @return null always
377      */

378     public DurationField getLeapDurationField() {
379         return null;
380     }
381
382     /**
383      * Always throws UnsupportedOperationException
384      *
385      * @throws UnsupportedOperationException
386      */

387     public int getMinimumValue() {
388         throw unsupported();
389     }
390
391     /**
392      * Always throws UnsupportedOperationException
393      *
394      * @throws UnsupportedOperationException
395      */

396     public int getMinimumValue(long instant) {
397         throw unsupported();
398     }
399
400     /**
401      * Always throws UnsupportedOperationException
402      *
403      * @throws UnsupportedOperationException
404      */

405     public int getMinimumValue(ReadablePartial instant) {
406         throw unsupported();
407     }
408
409     /**
410      * Always throws UnsupportedOperationException
411      *
412      * @throws UnsupportedOperationException
413      */

414     public int getMinimumValue(ReadablePartial instant, int[] values) {
415         throw unsupported();
416     }
417
418     /**
419      * Always throws UnsupportedOperationException
420      *
421      * @throws UnsupportedOperationException
422      */

423     public int getMaximumValue() {
424         throw unsupported();
425     }
426
427     /**
428      * Always throws UnsupportedOperationException
429      *
430      * @throws UnsupportedOperationException
431      */

432     public int getMaximumValue(long instant) {
433         throw unsupported();
434     }
435
436     /**
437      * Always throws UnsupportedOperationException
438      *
439      * @throws UnsupportedOperationException
440      */

441     public int getMaximumValue(ReadablePartial instant) {
442         throw unsupported();
443     }
444
445     /**
446      * Always throws UnsupportedOperationException
447      *
448      * @throws UnsupportedOperationException
449      */

450     public int getMaximumValue(ReadablePartial instant, int[] values) {
451         throw unsupported();
452     }
453
454     /**
455      * Always throws UnsupportedOperationException
456      *
457      * @throws UnsupportedOperationException
458      */

459     public int getMaximumTextLength(Locale JavaDoc locale) {
460         throw unsupported();
461     }
462
463     /**
464      * Always throws UnsupportedOperationException
465      *
466      * @throws UnsupportedOperationException
467      */

468     public int getMaximumShortTextLength(Locale JavaDoc locale) {
469         throw unsupported();
470     }
471
472     /**
473      * Always throws UnsupportedOperationException
474      *
475      * @throws UnsupportedOperationException
476      */

477     public long roundFloor(long instant) {
478         throw unsupported();
479     }
480
481     /**
482      * Always throws UnsupportedOperationException
483      *
484      * @throws UnsupportedOperationException
485      */

486     public long roundCeiling(long instant) {
487         throw unsupported();
488     }
489
490     /**
491      * Always throws UnsupportedOperationException
492      *
493      * @throws UnsupportedOperationException
494      */

495     public long roundHalfFloor(long instant) {
496         throw unsupported();
497     }
498
499     /**
500      * Always throws UnsupportedOperationException
501      *
502      * @throws UnsupportedOperationException
503      */

504     public long roundHalfCeiling(long instant) {
505         throw unsupported();
506     }
507
508     /**
509      * Always throws UnsupportedOperationException
510      *
511      * @throws UnsupportedOperationException
512      */

513     public long roundHalfEven(long instant) {
514         throw unsupported();
515     }
516
517     /**
518      * Always throws UnsupportedOperationException
519      *
520      * @throws UnsupportedOperationException
521      */

522     public long remainder(long instant) {
523         throw unsupported();
524     }
525
526     //------------------------------------------------------------------------
527
/**
528      * Get a suitable debug string.
529      *
530      * @return debug string
531      */

532     public String JavaDoc toString() {
533         return "UnsupportedDateTimeField";
534     }
535
536     /**
537      * Ensure proper singleton serialization
538      */

539     private Object JavaDoc readResolve() {
540         return getInstance(iType, iDurationField);
541     }
542
543     private UnsupportedOperationException JavaDoc unsupported() {
544         return new UnsupportedOperationException JavaDoc(iType + " field is unsupported");
545     }
546
547 }
548
Popular Tags