001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.lang.text; 018 019 import java.text.FieldPosition; 020 import java.text.Format; 021 import java.text.ParseException; 022 import java.text.ParsePosition; 023 024 /** 025 * Formats using one formatter and parses using a different formatter. An 026 * example of use for this would be a webapp where data is taken in one way and 027 * stored in a database another way. 028 * 029 * @author Archimedes Trajano 030 * @version $Id: CompositeFormat.java 598710 2007-11-27 17:34:34Z mbenson $ 031 */ 032 public class CompositeFormat extends Format { 033 034 /** 035 * Required for serialization support. 036 * 037 * @see java.io.Serializable 038 */ 039 private static final long serialVersionUID = -4329119827877627683L; 040 041 /** The parser to use. */ 042 private final Format parser; 043 /** The formatter to use. */ 044 private final Format formatter; 045 046 /** 047 * Create a format that points its parseObject method to one implementation 048 * and its format method to another. 049 * 050 * @param parser implementation 051 * @param formatter implementation 052 */ 053 public CompositeFormat(Format parser, Format formatter) { 054 this.parser = parser; 055 this.formatter = formatter; 056 } 057 058 /** 059 * Uses the formatter Format instance. 060 * 061 * @param obj the object to format 062 * @param toAppendTo the {@link StringBuffer} to append to 063 * @param pos the FieldPosition to use (or ignore). 064 * @return <code>toAppendTo</code> 065 * @see Format#format(Object, StringBuffer, FieldPosition) 066 */ 067 public StringBuffer format(Object obj, StringBuffer toAppendTo, 068 FieldPosition pos) { 069 return formatter.format(obj, toAppendTo, pos); 070 } 071 072 /** 073 * Uses the parser Format instance. 074 * 075 * @param source the String source 076 * @param pos the ParsePosition containing the position to parse from, will 077 * be updated according to parsing success (index) or failure 078 * (error index) 079 * @return the parsed Object 080 * @see Format#parseObject(String, ParsePosition) 081 */ 082 public Object parseObject(String source, ParsePosition pos) { 083 return parser.parseObject(source, pos); 084 } 085 086 /** 087 * Provides access to the parser Format implementation. 088 * 089 * @return parser Format implementation 090 */ 091 public Format getParser() { 092 return this.parser; 093 } 094 095 /** 096 * Provides access to the parser Format implementation. 097 * 098 * @return formatter Format implementation 099 */ 100 public Format getFormatter() { 101 return this.formatter; 102 } 103 104 /** 105 * Utility method to parse and then reformat a String. 106 * 107 * @param input String to reformat 108 * @return A reformatted String 109 * @throws ParseException thrown by parseObject(String) call 110 */ 111 public String reformat(String input) throws ParseException { 112 return format(parseObject(input)); 113 } 114 115 }