    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 *      https://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 */
    017package org.apache.commons.text;
    018
    019import java.text.FieldPosition;
    020import java.text.Format;
    021import java.text.ParseException;
    022import 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 * @since 1.0
    030 */
    031public class CompositeFormat extends Format {
    032
    033    /**
    034     * Required for serialization support.
    035     *
    036     * @see java.io.Serializable
    037     */
    038    private static final long serialVersionUID = -4329119827877627683L;
    039
    040    /** The parser to use. */
    041    private final Format parser;
    042
    043    /** The formatter to use. */
    044    private final Format formatter;
    045
    046    /**
    047     * Constructs 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(final Format parser, final Format formatter) {
    054        this.parser = parser;
    055        this.formatter = formatter;
    056    }
    057
    058    /**
    059     * Formats the input.
    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}.
    065     * @see Format#format(Object, StringBuffer, FieldPosition)
    066     */
    067    @Override // Therefore has to use StringBuffer
    068    public StringBuffer format(final Object obj, final StringBuffer toAppendTo,
    069            final FieldPosition pos) {
    070        return formatter.format(obj, toAppendTo, pos);
    071    }
    072
    073    /**
    074     * Gets the parser Format implementation.
    075     *
    076     * @return formatter Format implementation
    077     */
    078    public Format getFormatter() {
    079        return this.formatter;
    080    }
    081
    082    /**
    083     * Gets the parser Format implementation.
    084     *
    085     * @return parser Format implementation
    086     */
    087    public Format getParser() {
    088        return this.parser;
    089    }
    090
    091    /**
    092     * Parses the input.
    093     *
    094     * @param source the String source.
    095     * @param pos    the ParsePosition containing the position to parse from, will be updated according to parsing success (index) or failure (error index).
    096     * @return The parsed Object.
    097     * @see Format#parseObject(String, ParsePosition)
    098     */
    099    @Override
    100    public Object parseObject(final String source, final ParsePosition pos) {
    101        return parser.parseObject(source, pos);
    102    }
    103
    104    /**
    105     * Parses and then reformats 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(final String input) throws ParseException {
    112        return format(parseObject(input));
    113    }
    114
    115}