ConverterManager


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.convert;
17  
18  import org.joda.time.JodaTimePermission;
19  
20  /**
21   * ConverterManager controls the date and time converters.
22   * <p>
23   * This class enables additional conversion classes to be added via
24   * {@link #addInstantConverter(InstantConverter)}, which may replace an
25   * existing converter. Similar methods exist for duration, time period and
26   * interval converters.
27   * <p>
28   * This class is threadsafe, so adding/removing converters can be done at any
29   * time. Updating the set of convertors is relatively expensive, and so should
30   * not be performed often.
31   * <p>
32   * The default instant converters are:
33   * <ul>
34   * <li>ReadableInstant
35   * <li>String
36   * <li>Calendar
37   * <li>Date (includes sql package subclasses)
38   * <li>Long (milliseconds)
39   * <li>null (now)
40   * </ul>
41   * 
42   * The default partial converters are:
43   * <ul>
44   * <li>ReadablePartial
45   * <li>ReadableInstant
46   * <li>String
47   * <li>Calendar
48   * <li>Date (includes sql package subclasses)
49   * <li>Long (milliseconds)
50   * <li>null (now)
51   * </ul>
52   * 
53   * The default duration converters are:
54   * <ul>
55   * <li>ReadableDuration
56   * <li>ReadableInterval
57   * <li>String
58   * <li>Long (milliseconds)
59   * <li>null (zero ms)
60   * </ul>
61   *
62   * The default time period converters are:
63   * <ul>
64   * <li>ReadablePeriod
65   * <li>ReadableInterval
66   * <li>String
67   * <li>null (zero)
68   * </ul>
69   * 
70   * The default interval converters are:
71   * <ul>
72   * <li>ReadableInterval
73   * <li>String
74   * <li>null (zero-length from now to now)
75   * </ul>
76   *
77   * @author Stephen Colebourne
78   * @author Brian S O'Neill
79   * @since 1.0
80   */
81  public final class ConverterManager {
82  
83      /**
84       * Singleton instance, lazily loaded to avoid class loading.
85       */
86      private static ConverterManager INSTANCE;
87  
88      public static ConverterManager getInstance() {
89          if (INSTANCE == null) {
90              INSTANCE = new ConverterManager();
91          }
92          return INSTANCE;
93      }
94      
95      private ConverterSet iInstantConverters;
96      private ConverterSet iPartialConverters;
97      private ConverterSet iDurationConverters;
98      private ConverterSet iPeriodConverters;
99      private ConverterSet iIntervalConverters;
100     
101     /**
102      * Restricted constructor.
103      */
104     protected ConverterManager() {
105         super();
106 
107         iInstantConverters = new ConverterSet(new Converter[] {
108             ReadableInstantConverter.INSTANCE,
109             StringConverter.INSTANCE,
110             CalendarConverter.INSTANCE,
111             DateConverter.INSTANCE,
112             LongConverter.INSTANCE,
113             NullConverter.INSTANCE,
114         });
115 
116         iPartialConverters = new ConverterSet(new Converter[] {
117             ReadablePartialConverter.INSTANCE,
118             ReadableInstantConverter.INSTANCE,
119             StringConverter.INSTANCE,
120             CalendarConverter.INSTANCE,
121             DateConverter.INSTANCE,
122             LongConverter.INSTANCE,
123             NullConverter.INSTANCE,
124         });
125 
126         iDurationConverters = new ConverterSet(new Converter[] {
127             ReadableDurationConverter.INSTANCE,
128             ReadableIntervalConverter.INSTANCE,
129             StringConverter.INSTANCE,
130             LongConverter.INSTANCE,
131             NullConverter.INSTANCE,
132         });
133 
134         iPeriodConverters = new ConverterSet(new Converter[] {
135             ReadableDurationConverter.INSTANCE,
136             ReadablePeriodConverter.INSTANCE,
137             ReadableIntervalConverter.INSTANCE,
138             StringConverter.INSTANCE,
139             NullConverter.INSTANCE,
140         });
141 
142         iIntervalConverters = new ConverterSet(new Converter[] {
143             ReadableIntervalConverter.INSTANCE,
144             StringConverter.INSTANCE,
145             NullConverter.INSTANCE,
146         });
147     }
148 
149     //-----------------------------------------------------------------------
150     /**
151      * Gets the best converter for the object specified.
152      * 
153      * @param object  the object to convert
154      * @return the converter to use
155      * @throws IllegalArgumentException if no suitable converter
156      * @throws IllegalStateException if multiple converters match the type
157      * equally well
158      */
159     public InstantConverter getInstantConverter(Object   object) {
160         InstantConverter converter =
161             (InstantConverter)iInstantConverters.select(object == null ? null : object.getClass());
162         if (converter != null) {
163             return converter;
164         }
165         throw new IllegalArgumentException  ("No instant converter found for type: " +
166             (object == null ? "null" : object.getClass().getName()));
167     }
168     
169     //-----------------------------------------------------------------------
170     /**
171      * Gets a copy of the set of converters.
172      * 
173      * @return the converters, a copy of the real data, never null
174      */
175     public InstantConverter[] getInstantConverters() {
176         ConverterSet set = iInstantConverters;
177         InstantConverter[] converters = new InstantConverter[set.size()];
178         set.copyInto(converters);
179         return converters;
180     }
181     
182     /**
183      * Adds a converter to the set of converters. If a matching converter is
184      * already in the set, the given converter replaces it. If the converter is
185      * exactly the same as one already in the set, no changes are made.
186      * <p>
187      * The order in which converters are added is not relevent. The best
188      * converter is selected by examining the object hierarchy.
189      * 
190      * @param converter  the converter to add, null ignored
191      * @return replaced converter, or null
192      */
193     public InstantConverter addInstantConverter(InstantConverter converter)
194             throws SecurityException   {
195         
196         checkAlterInstantConverters();
197         if (converter == null) {
198             return null;
199         }
200         InstantConverter[] removed = new InstantConverter[1];
201         iInstantConverters = iInstantConverters.add(converter, removed);
202         return removed[0];
203     }
204     
205     /**
206      * Removes a converter from the set of converters. If the converter was
207      * not in the set, no changes are made.
208      * 
209      * @param converter  the converter to remove, null ignored
210      * @return replaced converter, or null
211      */
212     public InstantConverter removeInstantConverter(InstantConverter converter)
213             throws SecurityException   {
214         
215         checkAlterInstantConverters();
216         if (converter == null) {
217             return null;
218         }
219         InstantConverter[] removed = new InstantConverter[1];
220         iInstantConverters = iInstantConverters.remove(converter, removed);
221         return removed[0];
222     }
223     
224     /**
225      * Checks whether the user has permission 'ConverterManager.alterInstantConverters'.
226      * 
227      * @throws SecurityException if the user does not have the permission
228      */
229     private void checkAlterInstantConverters() throws SecurityException   {
230         SecurityManager   sm = System.getSecurityManager();
231         if (sm != null) {
232             sm.checkPermission(new JodaTimePermission("ConverterManager.alterInstantConverters"));
233         }
234     }
235 
236     //-----------------------------------------------------------------------
237     /**
238      * Gets the best converter for the object specified.
239      * 
240      * @param object  the object to convert
241      * @return the converter to use
242      * @throws IllegalArgumentException if no suitable converter
243      * @throws IllegalStateException if multiple converters match the type
244      * equally well
245      */
246     public PartialConverter getPartialConverter(Object   object) {
247         PartialConverter converter =
248             (PartialConverter)iPartialConverters.select(object == null ? null : object.getClass());
249         if (converter != null) {
250             return converter;
251         }
252         throw new IllegalArgumentException  ("No partial converter found for type: " +
253             (object == null ? "null" : object.getClass().getName()));
254     }
255     
256     //-----------------------------------------------------------------------
257     /**
258      * Gets a copy of the set of converters.
259      * 
260      * @return the converters, a copy of the real data, never null
261      */
262     public PartialConverter[] getPartialConverters() {
263         ConverterSet set = iPartialConverters;
264         PartialConverter[] converters = new PartialConverter[set.size()];
265         set.copyInto(converters);
266         return converters;
267     }
268     
269     /**
270      * Adds a converter to the set of converters. If a matching converter is
271      * already in the set, the given converter replaces it. If the converter is
272      * exactly the same as one already in the set, no changes are made.
273      * <p>
274      * The order in which converters are added is not relevent. The best
275      * converter is selected by examining the object hierarchy.
276      * 
277      * @param converter  the converter to add, null ignored
278      * @return replaced converter, or null
279      */
280     public PartialConverter addPartialConverter(PartialConverter converter)
281             throws SecurityException   {
282         
283         checkAlterPartialConverters();
284         if (converter == null) {
285             return null;
286         }
287         PartialConverter[] removed = new PartialConverter[1];
288         iPartialConverters = iPartialConverters.add(converter, removed);
289         return removed[0];
290     }
291     
292     /**
293      * Removes a converter from the set of converters. If the converter was
294      * not in the set, no changes are made.
295      * 
296      * @param converter  the converter to remove, null ignored
297      * @return replaced converter, or null
298      */
299     public PartialConverter removePartialConverter(PartialConverter converter)
300             throws SecurityException   {
301         
302         checkAlterPartialConverters();
303         if (converter == null) {
304             return null;
305         }
306         PartialConverter[] removed = new PartialConverter[1];
307         iPartialConverters = iPartialConverters.remove(converter, removed);
308         return removed[0];
309     }
310     
311     /**
312      * Checks whether the user has permission 'ConverterManager.alterPartialConverters'.
313      * 
314      * @throws SecurityException if the user does not have the permission
315      */
316     private void checkAlterPartialConverters() throws SecurityException   {
317         SecurityManager   sm = System.getSecurityManager();
318         if (sm != null) {
319             sm.checkPermission(new JodaTimePermission("ConverterManager.alterPartialConverters"));
320         }
321     }
322 
323     //-----------------------------------------------------------------------
324     /**
325      * Gets the best converter for the object specified.
326      * 
327      * @param object  the object to convert
328      * @return the converter to use
329      * @throws IllegalArgumentException if no suitable converter
330      * @throws IllegalStateException if multiple converters match the type
331      * equally well
332      */
333     public DurationConverter getDurationConverter(Object   object) {
334         DurationConverter converter =
335             (DurationConverter)iDurationConverters.select(object == null ? null : object.getClass());
336         if (converter != null) {
337             return converter;
338         }
339         throw new IllegalArgumentException  ("No duration converter found for type: " +
340             (object == null ? "null" : object.getClass().getName()));
341     }
342     
343     //-----------------------------------------------------------------------
344     /**
345      * Gets a copy of the list of converters.
346      * 
347      * @return the converters, a copy of the real data, never null
348      */
349     public DurationConverter[] getDurationConverters() {
350         ConverterSet set = iDurationConverters;
351         DurationConverter[] converters = new DurationConverter[set.size()];
352         set.copyInto(converters);
353         return converters;
354     }
355     
356     /**
357      * Adds a converter to the set of converters. If a matching converter is
358      * already in the set, the given converter replaces it. If the converter is
359      * exactly the same as one already in the set, no changes are made.
360      * <p>
361      * The order in which converters are added is not relevent. The best
362      * converter is selected by examining the object hierarchy.
363      * 
364      * @param converter  the converter to add, null ignored
365      * @return replaced converter, or null
366      */
367     public DurationConverter addDurationConverter(DurationConverter converter)
368             throws SecurityException   {
369         
370         checkAlterDurationConverters();
371         if (converter == null) {
372             return null;
373         }
374         DurationConverter[] removed = new DurationConverter[1];
375         iDurationConverters = iDurationConverters.add(converter, removed);
376         return removed[0];
377     }
378     
379     /**
380      * Removes a converter from the set of converters. If the converter was
381      * not in the set, no changes are made.
382      * 
383      * @param converter  the converter to remove, null ignored
384      * @return replaced converter, or null
385      */
386     public DurationConverter removeDurationConverter(DurationConverter converter)
387             throws SecurityException   {
388         
389         checkAlterDurationConverters();
390         if (converter == null) {
391             return null;
392         }
393         DurationConverter[] removed = new DurationConverter[1];
394         iDurationConverters = iDurationConverters.remove(converter, removed);
395         return removed[0];
396     }
397     
398     /**
399      * Checks whether the user has permission 'ConverterManager.alterDurationConverters'.
400      * 
401      * @throws SecurityException if the user does not have the permission
402      */
403     private void checkAlterDurationConverters() throws SecurityException   {
404         SecurityManager   sm = System.getSecurityManager();
405         if (sm != null) {
406             sm.checkPermission(new JodaTimePermission("ConverterManager.alterDurationConverters"));
407         }
408     }
409 
410     //-----------------------------------------------------------------------
411     /**
412      * Gets the best converter for the object specified.
413      * 
414      * @param object  the object to convert
415      * @return the converter to use
416      * @throws IllegalArgumentException if no suitable converter
417      * @throws IllegalStateException if multiple converters match the type
418      * equally well
419      */
420     public PeriodConverter getPeriodConverter(Object   object) {
421         PeriodConverter converter =
422             (PeriodConverter)iPeriodConverters.select(object == null ? null : object.getClass());
423         if (converter != null) {
424             return converter;
425         }
426         throw new IllegalArgumentException  ("No period converter found for type: " +
427             (object == null ? "null" : object.getClass().getName()));
428     }
429     
430     //-----------------------------------------------------------------------
431     /**
432      * Gets a copy of the list of converters.
433      * 
434      * @return the converters, a copy of the real data, never null
435      */
436     public PeriodConverter[] getPeriodConverters() {
437         ConverterSet set = iPeriodConverters;
438         PeriodConverter[] converters = new PeriodConverter[set.size()];
439         set.copyInto(converters);
440         return converters;
441     }
442     
443     /**
444      * Adds a converter to the set of converters. If a matching converter is
445      * already in the set, the given converter replaces it. If the converter is
446      * exactly the same as one already in the set, no changes are made.
447      * <p>
448      * The order in which converters are added is not relevent. The best
449      * converter is selected by examining the object hierarchy.
450      * 
451      * @param converter  the converter to add, null ignored
452      * @return replaced converter, or null
453      */
454     public PeriodConverter addPeriodConverter(PeriodConverter converter)
455             throws SecurityException   {
456         
457         checkAlterPeriodConverters();
458         if (converter == null) {
459             return null;
460         }
461         PeriodConverter[] removed = new PeriodConverter[1];
462         iPeriodConverters = iPeriodConverters.add(converter, removed);
463         return removed[0];
464     }
465     
466     /**
467      * Removes a converter from the set of converters. If the converter was
468      * not in the set, no changes are made.
469      * 
470      * @param converter  the converter to remove, null ignored
471      * @return replaced converter, or null
472      */
473     public PeriodConverter removePeriodConverter(PeriodConverter converter)
474             throws SecurityException   {
475         
476         checkAlterPeriodConverters();
477         if (converter == null) {
478             return null;
479         }
480         PeriodConverter[] removed = new PeriodConverter[1];
481         iPeriodConverters = iPeriodConverters.remove(converter, removed);
482         return removed[0];
483     }
484     
485     /**
486      * Checks whether the user has permission 'ConverterManager.alterPeriodConverters'.
487      * 
488      * @throws SecurityException if the user does not have the permission
489      */
490     private void checkAlterPeriodConverters() throws SecurityException   {
491         SecurityManager   sm = System.getSecurityManager();
492         if (sm != null) {
493             sm.checkPermission(new JodaTimePermission("ConverterManager.alterPeriodConverters"));
494         }
495     }
496 
497     //-----------------------------------------------------------------------
498     /**
499      * Gets the best converter for the object specified.
500      * 
501      * @param object  the object to convert
502      * @return the converter to use
503      * @throws IllegalArgumentException if no suitable converter
504      * @throws IllegalStateException if multiple converters match the type
505      * equally well
506      */
507     public IntervalConverter getIntervalConverter(Object   object) {
508         IntervalConverter converter =
509             (IntervalConverter)iIntervalConverters.select(object == null ? null : object.getClass());
510         if (converter != null) {
511             return converter;
512         }
513         throw new IllegalArgumentException  ("No interval converter found for type: " +
514             (object == null ? "null" : object.getClass().getName()));
515     }
516     
517     //-----------------------------------------------------------------------
518     /**
519      * Gets a copy of the list of converters.
520      * 
521      * @return the converters, a copy of the real data, never null
522      */
523     public IntervalConverter[] getIntervalConverters() {
524         ConverterSet set = iIntervalConverters;
525         IntervalConverter[] converters = new IntervalConverter[set.size()];
526         set.copyInto(converters);
527         return converters;
528     }
529     
530     /**
531      * Adds a converter to the set of converters. If a matching converter is
532      * already in the set, the given converter replaces it. If the converter is
533      * exactly the same as one already in the set, no changes are made.
534      * <p>
535      * The order in which converters are added is not relevent. The best
536      * converter is selected by examining the object hierarchy.
537      * 
538      * @param converter  the converter to add, null ignored
539      * @return replaced converter, or null
540      */
541     public IntervalConverter addIntervalConverter(IntervalConverter converter) 
542             throws SecurityException   {
543         
544         checkAlterIntervalConverters();
545         if (converter == null) {
546             return null;
547         }
548         IntervalConverter[] removed = new IntervalConverter[1];
549         iIntervalConverters = iIntervalConverters.add(converter, removed);
550         return removed[0];
551     }
552     
553     /**
554      * Removes a converter from the set of converters. If the converter was
555      * not in the set, no changes are made.
556      * 
557      * @param converter  the converter to remove, null ignored
558      * @return replaced converter, or null
559      */
560     public IntervalConverter removeIntervalConverter(IntervalConverter converter)
561             throws SecurityException   {
562         
563         checkAlterIntervalConverters();
564         if (converter == null) {
565             return null;
566         }
567         IntervalConverter[] removed = new IntervalConverter[1];
568         iIntervalConverters = iIntervalConverters.remove(converter, removed);
569         return removed[0];
570     }
571     
572     /**
573      * Checks whether the user has permission 'ConverterManager.alterIntervalConverters'.
574      * 
575      * @throws SecurityException if the user does not have the permission
576      */
577     private void checkAlterIntervalConverters() throws SecurityException   {
578         SecurityManager   sm = System.getSecurityManager();
579         if (sm != null) {
580             sm.checkPermission(new JodaTimePermission("ConverterManager.alterIntervalConverters"));
581         }
582     }
583 
584     //-----------------------------------------------------------------------
585     /**
586      * Gets a debug representation of the object.
587      */
588     public String   toString() {
589         return "ConverterManager[" +
590             iInstantConverters.size() + " instant," +
591             iPartialConverters.size() + " partial," +
592             iDurationConverters.size() + " duration," +
593             iPeriodConverters.size() + " period," +
594             iIntervalConverters.size() + " interval]";
595     }
596 
597 }
598
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags