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.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 * @since 1.0 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 43 /** The formatter to use. */ 44 private final Format formatter; 45 46 /** 47 * Constructs a format that points its parseObject method to one implementation 48 * and its format method to another. 49 * 50 * @param parser implementation 51 * @param formatter implementation 52 */ 53 public CompositeFormat(final Format parser, final Format formatter) { 54 this.parser = parser; 55 this.formatter = formatter; 56 } 57 58 /** 59 * Formats the input. 60 * 61 * @param obj the object to format 62 * @param toAppendTo the {@link StringBuffer} to append to 63 * @param pos the FieldPosition to use (or ignore). 64 * @return {@code toAppendTo} 65 * @see Format#format(Object, StringBuffer, FieldPosition) 66 */ 67 @Override // Therefore has to use StringBuffer 68 public StringBuffer format(final Object obj, final StringBuffer toAppendTo, 69 final FieldPosition pos) { 70 return formatter.format(obj, toAppendTo, pos); 71 } 72 73 /** 74 * Gets the parser Format implementation. 75 * 76 * @return formatter Format implementation 77 */ 78 public Format getFormatter() { 79 return this.formatter; 80 } 81 82 /** 83 * Gets the parser Format implementation. 84 * 85 * @return parser Format implementation 86 */ 87 public Format getParser() { 88 return this.parser; 89 } 90 91 /** 92 * Parses the input. 93 * 94 * @param source the String source 95 * @param pos the ParsePosition containing the position to parse from, will 96 * be updated according to parsing success (index) or failure 97 * (error index) 98 * @return The parsed Object 99 * @see Format#parseObject(String, ParsePosition) 100 */ 101 @Override 102 public Object parseObject(final String source, final ParsePosition pos) { 103 return parser.parseObject(source, pos); 104 } 105 106 /** 107 * Parses and then reformats a String. 108 * 109 * @param input String to reformat 110 * @return A reformatted String 111 * @throws ParseException thrown by parseObject(String) call 112 */ 113 public String reformat(final String input) throws ParseException { 114 return format(parseObject(input)); 115 } 116 117 }