AppendableJoiner.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.commons.lang3;

import java.io.IOException;
import java.util.Iterator;
import java.util.StringJoiner;
import java.util.function.Supplier;

import org.apache.commons.lang3.exception.UncheckedException;
import org.apache.commons.lang3.function.FailableBiConsumer;

/**
 * Joins an array or {@link Iterable} into an existing {@link Appendable} like a {@link StringBuilder}; with the goal for call sites to avoid creating
 * intermediary Strings. This is like {@link String#join(CharSequence, CharSequence...)}, {@link String#join(CharSequence, Iterable)}, and {@link StringJoiner}.
 * <p>
 * Keep an instance in a (static) variable for efficient joining into an {@link Appendable} or {@link StringBuilder} without creating temporary Strings.
 * </p>
 * <p>
 * Use the builder and instance methods to reuse the same kind of joining prefix, suffix, delimiter, and string conversion.
 * </p>
 * <p>
 * For example:
 * </p>
 *
 * <pre>{@code
 * // A reuseable instance
 * private static final AppendableJoiner<Object> JOINER = AppendableJoiner.builder()
 *     .setPrefix("[")
 *     .setSuffix("]")
 *     .setDelimiter(", ")
 *     .get();
 * }
 * ...
 * // Builds straight into a StringBuilder:
 * StringBuilder sbuilder = new StringBuilder("1");
 * JOINER.join(sbuilder, "A", "B");
 * sbuilder.append("2");
 * JOINER.join(sbuilder, "C", "D");
 * sbuilder.append("3");
 * // Returns "1[A, B]2[C, D]3"
 * return sbuilder.toString();
 * }</pre>
 * <p>
 * To provide a custom Object element to {@link CharSequence} converter, call {@link Builder#setElementAppender(FailableBiConsumer)}, for example:
 * </p>
 *
 * <pre>{@code
 * private static final AppendableJoiner<Item> JOINER = AppendableJoiner.builder()
 *     .setElementAppender(e -> (a, e) -> a.append(e.getFoo())
 *                                        a.append(e.getBar())
 *                                        a.append('!'))
 *     ...
 *     .get();
 * }
 * }</pre>
 * <p>
 * This class is immutable and thread-safe.
 * </p>
 *
 * @param <T> the type of elements to join
 * @see Appendable
 * @see StringBuilder
 * @see String#join(CharSequence, CharSequence...)
 * @see String#join(CharSequence, Iterable)
 * @see StringJoiner
 * @since 3.15.0
 */
public final class AppendableJoiner<T> {

    /**
     * Builds instances of {@link AppendableJoiner}.
     *
     * @param <T> the type of elements to join
     */
    public static final class Builder<T> implements Supplier<AppendableJoiner<T>> {

        /** The sequence of characters to be used at the beginning. */
        private CharSequence prefix;

        /** The sequence of characters to be used at the end. */
        private CharSequence suffix;

        /** The delimiter that separates each element. */
        private CharSequence delimiter;

        /**
         * The consumer used to render each element of type {@code T} onto an {@link Appendable}.
         */
        private FailableBiConsumer<Appendable, T, IOException> appender;

        /**
         * Constructs a new instance.
         */
        Builder() {
            // empty
        }

        /**
         * Gets a new instance of {@link AppendableJoiner}.
         */
        @Override
        public AppendableJoiner<T> get() {
            return new AppendableJoiner<>(prefix, suffix, delimiter, appender);
        }

        /**
         * Sets the delimiter that separates each element.
         *
         * @param delimiter the delimiter that separates each element
         * @return {@code this} instance
         */
        public Builder<T> setDelimiter(final CharSequence delimiter) {
            this.delimiter = delimiter;
            return this;
        }

        /**
         * Sets the consumer used to render each element of type {@code T} onto an {@link Appendable}.
         *
         * @param appender the consumer used to render each element of type {@code T} onto an {@link Appendable}
         * @return {@code this} instance
         */
        public Builder<T> setElementAppender(final FailableBiConsumer<Appendable, T, IOException> appender) {
            this.appender = appender;
            return this;
        }

        /**
         * Sets the sequence of characters to be used at the beginning.
         *
         * @param prefix the sequence of characters to be used at the beginning
         * @return {@code this} instance
         */
        public Builder<T> setPrefix(final CharSequence prefix) {
            this.prefix = prefix;
            return this;
        }

        /**
         * Sets the sequence of characters to be used at the end.
         *
         * @param suffix the sequence of characters to be used at the end
         * @return {@code this} instance
         */
        public Builder<T> setSuffix(final CharSequence suffix) {
            this.suffix = suffix;
            return this;
        }

    }

    /**
     * Creates a new builder.
     *
     * @param <T> the type of elements
     * @return a new builder
     */
    public static <T> Builder<T> builder() {
        return new Builder<>();
    }

    /** Could be public in the future, in some form. */
    @SafeVarargs
    static <A extends Appendable, T> A joinA(final A appendable, final CharSequence prefix, final CharSequence suffix, final CharSequence delimiter,
            final FailableBiConsumer<Appendable, T, IOException> appender, final T... elements) throws IOException {
        return joinArray(appendable, prefix, suffix, delimiter, appender, elements);
    }

    private static <A extends Appendable, T> A joinArray(final A appendable, final CharSequence prefix, final CharSequence suffix, final CharSequence delimiter,
            final FailableBiConsumer<Appendable, T, IOException> appender, final T[] elements) throws IOException {
        appendable.append(prefix);
        if (elements != null) {
            if (elements.length > 0) {
                appender.accept(appendable, elements[0]);
            }
            for (int i = 1; i < elements.length; i++) {
                appendable.append(delimiter);
                appender.accept(appendable, elements[i]);
            }
        }
        appendable.append(suffix);
        return appendable;
    }

    /** Could be public in the future, in some form. */
    static <T> StringBuilder joinI(final StringBuilder stringBuilder, final CharSequence prefix, final CharSequence suffix, final CharSequence delimiter,
            final FailableBiConsumer<Appendable, T, IOException> appender, final Iterable<T> elements) {
        try {
            return joinIterable(stringBuilder, prefix, suffix, delimiter, appender, elements);
        } catch (final IOException e) {
            // Cannot happen with a StringBuilder.
            throw new UncheckedException(e);
        }
    }

    private static <A extends Appendable, T> A joinIterable(final A appendable, final CharSequence prefix, final CharSequence suffix,
            final CharSequence delimiter, final FailableBiConsumer<Appendable, T, IOException> appender, final Iterable<T> elements) throws IOException {
        appendable.append(prefix);
        if (elements != null) {
            final Iterator<T> iterator = elements.iterator();
            if (iterator.hasNext()) {
                appender.accept(appendable, iterator.next());
            }
            while (iterator.hasNext()) {
                appendable.append(delimiter);
                appender.accept(appendable, iterator.next());
            }
        }
        appendable.append(suffix);
        return appendable;
    }

    /** Could be public in the future, in some form. */
    @SafeVarargs
    static <T> StringBuilder joinSB(final StringBuilder stringBuilder, final CharSequence prefix, final CharSequence suffix, final CharSequence delimiter,
            final FailableBiConsumer<Appendable, T, IOException> appender, final T... elements) {
        try {
            return joinArray(stringBuilder, prefix, suffix, delimiter, appender, elements);
        } catch (final IOException e) {
            // Cannot happen with a StringBuilder.
            throw new UncheckedException(e);
        }
    }

    private static CharSequence nonNull(final CharSequence value) {
        return value != null ? value : StringUtils.EMPTY;
    }

    /** The sequence of characters to be used at the beginning. */
    private final CharSequence prefix;

    /** The sequence of characters to be used at the end. */
    private final CharSequence suffix;

    /** The delimiter that separates each element. */
    private final CharSequence delimiter;

    private final FailableBiConsumer<Appendable, T, IOException> appender;

    /**
     * Constructs a new instance.
     */
    private AppendableJoiner(final CharSequence prefix, final CharSequence suffix, final CharSequence delimiter,
            final FailableBiConsumer<Appendable, T, IOException> appender) {
        this.prefix = nonNull(prefix);
        this.suffix = nonNull(suffix);
        this.delimiter = nonNull(delimiter);
        this.appender = appender != null ? appender : (a, e) -> a.append(String.valueOf(e));
    }

    /**
     * Joins stringified objects from the given Iterable into a StringBuilder.
     *
     * @param stringBuilder the target
     * @param elements      the source
     * @return the given StringBuilder
     */
    public StringBuilder join(final StringBuilder stringBuilder, final Iterable<T> elements) {
        return joinI(stringBuilder, prefix, suffix, delimiter, appender, elements);
    }

    /**
     * Joins stringified objects from the given array into a StringBuilder.
     *
     * @param stringBuilder the target
     * @param elements      the source
     * @return the given target StringBuilder
     */
    public StringBuilder join(final StringBuilder stringBuilder, @SuppressWarnings("unchecked") final T... elements) {
        return joinSB(stringBuilder, prefix, suffix, delimiter, appender, elements);
    }

    /**
     * Joins stringified objects from the given Iterable into an Appendable.
     *
     * @param <A>        the Appendable type
     * @param appendable the target
     * @param elements   the source
     * @return the given StringBuilder
     * @throws IOException if an I/O error occurs
     */
    public <A extends Appendable> A joinA(final A appendable, final Iterable<T> elements) throws IOException {
        return joinIterable(appendable, prefix, suffix, delimiter, appender, elements);
    }

    /**
     * Joins stringified objects from the given array into an Appendable.
     *
     * @param <A>        the Appendable type
     * @param appendable the target
     * @param elements   the source
     * @return the given StringBuilder
     * @throws IOException if an I/O error occurs
     */
    public <A extends Appendable> A joinA(final A appendable, @SuppressWarnings("unchecked") final T... elements) throws IOException {
        return joinA(appendable, prefix, suffix, delimiter, appender, elements);
    }

}