View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.lang3.text;
18  
19  import java.text.FieldPosition;
20  import java.text.Format;
21  import java.text.ParseException;
22  import java.text.ParsePosition;
23  
24  /**
25   * Formats using one formatter and parses using a different formatter. An
26   * example of use for this would be a webapp where data is taken in one way and
27   * stored in a database another way.
28   * 
29   * @version $Id: CompositeFormat.java 1436768 2013-01-22 07:07:42Z ggregory $
30   */
31  public class CompositeFormat extends Format {
32  
33      /**
34       * Required for serialization support.
35       * 
36       * @see java.io.Serializable
37       */
38      private static final long serialVersionUID = -4329119827877627683L;
39  
40      /** The parser to use. */
41      private final Format parser;
42      /** The formatter to use. */
43      private final Format formatter;
44  
45      /**
46       * Create a format that points its parseObject method to one implementation
47       * and its format method to another.
48       * 
49       * @param parser implementation
50       * @param formatter implementation
51       */
52      public CompositeFormat(final Format parser, final Format formatter) {
53          this.parser = parser;
54          this.formatter = formatter;
55      }
56  
57      /**
58       * Uses the formatter Format instance.
59       * 
60       * @param obj the object to format
61       * @param toAppendTo the {@link StringBuffer} to append to
62       * @param pos the FieldPosition to use (or ignore).
63       * @return <code>toAppendTo</code>
64       * @see Format#format(Object, StringBuffer, FieldPosition)
65       */
66      @Override // Therefore has to use StringBuffer
67      public StringBuffer format(final Object obj, final StringBuffer toAppendTo,
68              final FieldPosition pos) {
69          return formatter.format(obj, toAppendTo, pos);
70      }
71  
72      /**
73       * Uses the parser Format instance.
74       * 
75       * @param source the String source
76       * @param pos the ParsePosition containing the position to parse from, will
77       *            be updated according to parsing success (index) or failure
78       *            (error index)
79       * @return the parsed Object
80       * @see Format#parseObject(String, ParsePosition)
81       */
82      @Override
83      public Object parseObject(final String source, final ParsePosition pos) {
84          return parser.parseObject(source, pos);
85      }
86  
87      /**
88       * Provides access to the parser Format implementation.
89       * 
90       * @return parser Format implementation
91       */
92      public Format getParser() {
93          return this.parser;
94      }
95  
96      /**
97       * Provides access to the parser Format implementation.
98       * 
99       * @return formatter Format implementation
100      */
101     public Format getFormatter() {
102         return this.formatter;
103     }
104 
105     /**
106      * Utility method to parse and then reformat a String.
107      * 
108      * @param input String to reformat
109      * @return A reformatted String
110      * @throws ParseException thrown by parseObject(String) call
111      */
112     public String reformat(final String input) throws ParseException {
113         return format(parseObject(input));
114     }
115 
116 }