201508.mbox/raw/%3c20150825181313.EE3D7AC05CA@hades.apache.org%3e

+    /*
+     * 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
+     *
+     *      http://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.csv;
+
+    import static org.apache.commons.csv.Constants.COMMENT;
+    import static org.apache.commons.csv.Constants.CR;
+    import static org.apache.commons.csv.Constants.LF;
+    import static org.apache.commons.csv.Constants.SP;
+
+    import java.io.Closeable;
+    import java.io.Flushable;
+    import java.io.IOException;
+    import java.sql.ResultSet;
+    import java.sql.SQLException;
+
+    /**
+     * Prints values in a CSV format.
+     *
+     * @version $Id: CSVPrinter.java 1695167 2015-08-10 21:08:58Z ggregory $
+     */
+    public final class CSVPrinter implements Flushable, Closeable {
+
+        /** The place that the values get written. */
+        private final Appendable out;
+        private final CSVFormat format;
+
+        /** True if we just began a new record. */
+        private boolean newRecord = true;
+
+        /**
+         * Creates a printer that will print values to the given stream following the CSVFormat.
+         * <p>
+         * Currently, only a pure encapsulation format or a pure escaping format is supported. Hybrid formats (encapsulation
+         * and escaping with a different character) are not supported.
+         * </p>
+         *
+         * @param out
+         *            stream to which to print. Must not be null.
+         * @param format
+         *            the CSV format. Must not be null.
+         * @throws IOException
+         *             thrown if the optional header cannot be printed.
+         * @throws IllegalArgumentException
+         *             thrown if the parameters of the format are inconsistent or if either out or format are null.
+         */
+        public CSVPrinter(final Appendable out, final CSVFormat format) throws IOException {
+            Assertions.notNull(out, "out");
+            Assertions.notNull(format, "format");
+
+            this.out = out;
+            this.format = format;
+            // TODO: Is it a good idea to do this here instead of on the first call to a print method?
+            // It seems a pain to have to track whether the header has already been printed or not.
+            if (format.getHeaderComments() != null) {
+                for (final String line : format.getHeaderComments()) {
+                    if (line != null) {
+                        this.printComment(line);
+                    }
+                }
+            }
+            if (format.getHeader() != null) {
+                this.printRecord((Object[]) format.getHeader());
+            }
+        }
+
+        // ======================================================
+        // printing implementation
+        // ======================================================
+
+        @Override
+        public void close() throws IOException {
+            if (out instanceof Closeable) {
+                ((Closeable) out).close();
+            }
+        }
+
+        /**
+         * Flushes the underlying stream.
+         *
+         * @throws IOException
+         *             If an I/O error occurs
+         */
+        @Override
+        public void flush() throws IOException {
+            if (out instanceof Flushable) {
+                ((Flushable) out).flush();
+            }
+        }
+
+        /**
+         * Gets the target Appendable.
+         *
+         * @return the target Appendable.
+         */
+        public Appendable getOut() {
+            return this.out;
+        }
+
+        /**
+         * Prints the string as the next value on the line. The value will be escaped or encapsulated as needed.
+         *
+         * @param value
+         *            value to be output.
+         * @throws IOException
+         *             If an I/O error occurs
+         */
+        public void print(final Object value) throws IOException {
+            // null values are considered empty
+            String strValue;
+            if (value == null) {
+                final String nullString = format.getNullString();
+                strValue = nullString == null ? Constants.EMPTY : nullString;
+            } else {
+                strValue = value.toString();
+            }
+            this.print(value, strValue, 0, strValue.length());
+        }
+
+        private void print(final Object object, final CharSequence value, final int offset, final int len)
+                throws IOException {
+            if (!newRecord) {
+                out.append(format.getDelimiter());
+            }
+            if (format.isQuoteCharacterSet()) {
+                // the original object is needed so can check for Number
+                printAndQuote(object, value, offset, len);
+            } else if (format.isEscapeCharacterSet()) {
+                printAndEscape(value, offset, len);
+            } else {
+                out.append(value, offset, offset + len);
+            }
+            newRecord = false;
+        }
+
+        /*
+         * Note: must only be called if escaping is enabled, otherwise will generate NPE
+         */
+        private void printAndEscape(final CharSequence value, final int offset, final int len) throws IOException {
+            int start = offset;
+            int pos = offset;
+            final int end = offset + len;
+
+            final char delim = format.getDelimiter();
+            final char escape = format.getEscapeCharacter().charValue();
+
+            while (pos < end) {
+                char c = value.charAt(pos);
+                if (c == CR || c == LF || c == delim || c == escape) {
+                    // write out segment up until this char
+                    if (pos > start) {
+                        out.append(value, start, pos);
+                    }
+                    if (c == LF) {
+                        c = 'n';
+                    } else if (c == CR) {
+                        c = 'r';
+                    }
+
+                    out.append(escape);
+                    out.append(c);
+
+                    start = pos + 1; // start on the current char after this one
+                }
+
+                pos++;
+            }
+
+            // write last segment
+            if (pos > start) {
+                out.append(value, start, pos);
+            }
+        }
+
+        /*
+         * Note: must only be called if quoting is enabled, otherwise will generate NPE
+         */
+        // the original object is needed so can check for Number
+        private void printAndQuote(final Object object, final CharSequence value, final int offset, final int len)
+                throws IOException {
+            boolean quote = false;
+            int start = offset;
+            int pos = offset;
+            final int end = offset + len;
+
+            final char delimChar = format.getDelimiter();
+            final char quoteChar = format.getQuoteCharacter().charValue();
+
+            QuoteMode quoteModePolicy = format.getQuoteMode();
+            if (quoteModePolicy == null) {
+                quoteModePolicy = QuoteMode.MINIMAL;
+            }
+            switch (quoteModePolicy) {
+            case ALL:
+                quote = true;
+                break;
+            case NON_NUMERIC:
+                quote = !(object instanceof Number);
+                break;
+            case NONE:
+                // Use the existing escaping code
+                printAndEscape(value, offset, len);
+                return;
+            case MINIMAL:
+                if (len <= 0) {
+                    // always quote an empty token that is the first
+                    // on the line, as it may be the only thing on the
+                    // line. If it were not quoted in that case,
+                    // an empty line has no tokens.
+                    if (newRecord) {
+                        quote = true;
+                    }
+                } else {
+                    char c = value.charAt(pos);
+
+                    // TODO where did this rule come from?
+                    if (newRecord && (c < '0' || (c > '9' && c < 'A') || (c > 'Z' && c < 'a') || (c > 'z'))) {
+                        quote = true;
+                    } else if (c <= COMMENT) {
+                        // Some other chars at the start of a value caused the parser to fail, so for now
+                        // encapsulate if we start in anything less than '#'. We are being conservative
+                        // by including the default comment char too.
+                        quote = true;
+                    } else {
+                        while (pos < end) {
+                            c = value.charAt(pos);
+                            if (c == LF || c == CR || c == quoteChar || c == delimChar) {
+                                quote = true;
+                                break;
+                            }
+                            pos++;
+                        }
+
+                        if (!quote) {
+                            pos = end - 1;
+                            c = value.charAt(pos);
+                            // Some other chars at the end caused the parser to fail, so for now
+                            // encapsulate if we end in anything less than ' '
+                            if (c <= SP) {
+                                quote = true;
+                            }
+                        }
+                    }
+                }
+
+                if (!quote) {
+                    // no encapsulation needed - write out the original value
+                    out.append(value, start, end);
+                    return;
+                }
+                break;
+            default:
+                throw new IllegalStateException("Unexpected Quote value: " + quoteModePolicy);
+            }
+
+            if (!quote) {
+                // no encapsulation needed - write out the original value
+                out.append(value, start, end);
+                return;
+            }
+
+            // we hit something that needed encapsulation
+            out.append(quoteChar);
+
+            // Pick up where we left off: pos should be positioned on the first character that caused
+            // the need for encapsulation.
+            while (pos < end) {
+                final char c = value.charAt(pos);
+                if (c == quoteChar) {
+                    // write out the chunk up until this point
+
+                    // add 1 to the length to write out the encapsulator also
+                    out.append(value, start, pos + 1);
+                    // put the next starting position on the encapsulator so we will
+                    // write it out again with the next string (effectively doubling it)
+                    start = pos;
+                }
+                pos++;
+            }
+
+            // write the last segment
+            out.append(value, start, pos);
+            out.append(quoteChar);
+        }
+
+        /**
+         * Prints a comment on a new line among the delimiter separated values.
+         *
+         * <p>
+         * Comments will always begin on a new line and occupy a least one full line. The character specified to start
+         * comments and a space will be inserted at the beginning of each new line in the comment.
+         * </p>
+         *
+         * If comments are disabled in the current CSV format this method does nothing.
+         *
+         * @param comment
+         *            the comment to output
+         * @throws IOException
+         *             If an I/O error occurs
+         */
+        public void printComment(final String comment) throws IOException {
+            if (!format.isCommentMarkerSet()) {
+                return;
+            }
+            if (!newRecord) {
+                println();
+            }
+            out.append(format.getCommentMarker().charValue());
+            out.append(SP);
+            for (int i = 0; i < comment.length(); i++) {
+                final char c = comment.charAt(i);
+                switch (c) {
+                case CR:
+                    if (i + 1 < comment.length() && comment.charAt(i + 1) == LF) {
+                        i++;
+                    }
+                    //$FALL-THROUGH$ break intentionally excluded.
+                case LF:
+                    println();
+                    out.append(format.getCommentMarker().charValue());
+                    out.append(SP);
+                    break;
+                default:
+                    out.append(c);
+                    break;
+                }
+            }
+            println();
+        }
+
+        /**
+         * Outputs the record separator.
+         *
+         * @throws IOException
+         *             If an I/O error occurs
+         */
+        public void println() throws IOException {
+            final String recordSeparator = format.getRecordSeparator();
+            if (recordSeparator != null) {
+                out.append(recordSeparator);
+            }
+            newRecord = true;
+        }
+
+        /**
+         * Prints the given values a single record of delimiter separated values followed by the record separator.
+         *
+         * <p>
+         * The values will be quoted if needed. Quotes and newLine characters will be escaped. This method adds the record
+         * separator to the output after printing the record, so there is no need to call {@link #println()}.
+         * </p>
+         *
+         * @param values
+         *            values to output.
+         * @throws IOException
+         *             If an I/O error occurs
+         */
+        public void printRecord(final Iterable<?> values) throws IOException {
+            for (final Object value : values) {
+                print(value);
+            }
+            println();
+        }
+
+        /**
+         * Prints the given values a single record of delimiter separated values followed by the record separator.
+         *
+         * <p>
+         * The values will be quoted if needed. Quotes and newLine characters will be escaped. This method adds the record
+         * separator to the output after printing the record, so there is no need to call {@link #println()}.
+         * </p>
+         *
+         * @param values
+         *            values to output.
+         * @throws IOException
+         *             If an I/O error occurs
+         */
+        public void printRecord(final Object... values) throws IOException {
+            for (final Object value : values) {
+                print(value);
+            }
+            println();
+        }
+
+        /**
+         * Prints all the objects in the given collection handling nested collections/arrays as records.
+         *
+         * <p>
+         * If the given collection only contains simple objects, this method will print a single record like
+         * {@link #printRecord(Iterable)}. If the given collections contains nested collections/arrays those nested elements
+         * will each be printed as records using {@link #printRecord(Object...)}.
+         * </p>
+         *
+         * <p>
+         * Given the following data structure:
+         * </p>
+         *
+         * <pre>
+         * <code>
+         * List&lt;String[]&gt; data = ...
+         * data.add(new String[]{ "A", "B", "C" });
+         * data.add(new String[]{ "1", "2", "3" });
+         * data.add(new String[]{ "A1", "B2", "C3" });
+         * </code>
+         * </pre>
+         *
+         * <p>
+         * Calling this method will print:
+         * </p>
+         *
+         * <pre>
+         * <code>
+         * A, B, C
+         * 1, 2, 3
+         * A1, B2, C3
+         * </code>
+         * </pre>
+         *
+         * @param values
+         *            the values to print.
+         * @throws IOException
+         *             If an I/O error occurs
+         */
+        public void printRecords(final Iterable<?> values) throws IOException {
+            for (final Object value : values) {
+                if (value instanceof Object[]) {
+                    this.printRecord((Object[]) value);
+                } else if (value instanceof Iterable) {
+                    this.printRecord((Iterable<?>) value);
+                } else {
+                    this.printRecord(value);
+                }
+            }
+        }
+
+        /**
+         * Prints all the objects in the given array handling nested collections/arrays as records.
+         *
+         * <p>
+         * If the given array only contains simple objects, this method will print a single record like
+         * {@link #printRecord(Object...)}. If the given collections contains nested collections/arrays those nested
+         * elements will each be printed as records using {@link #printRecord(Object...)}.
+         * </p>
+         *
+         * <p>
+         * Given the following data structure:
+         * </p>
+         *
+         * <pre>
+         * <code>
+         * String[][] data = new String[3][]
+         * data[0] = String[]{ "A", "B", "C" };
+         * data[1] = new String[]{ "1", "2", "3" };
+         * data[2] = new String[]{ "A1", "B2", "C3" };
+         * </code>
+         * </pre>
+         *
+         * <p>
+         * Calling this method will print:
+         * </p>
+         *
+         * <pre>
+         * <code>
+         * A, B, C
+         * 1, 2, 3
+         * A1, B2, C3
+         * </code>
+         * </pre>
+         *
+         * @param values
+         *            the values to print.
+         * @throws IOException
+         *             If an I/O error occurs
+         */
+        public void printRecords(final Object... values) throws IOException {
+            for (final Object value : values) {
+                if (value instanceof Object[]) {
+                    this.printRecord((Object[]) value);
+                } else if (value instanceof Iterable) {
+                    this.printRecord((Iterable<?>) value);
+                } else {
+                    this.printRecord(value);
+                }
+            }
+        }
+
+        /**
+         * Prints all the objects in the given JDBC result set.
+         *
+         * @param resultSet
+         *            result set the values to print.
+         * @throws IOException
+         *             If an I/O error occurs
+         * @throws SQLException
+         *             if a database access error occurs
+         */
+        public void printRecords(final ResultSet resultSet) throws SQLException, IOException {
+            final int columnCount = resultSet.getMetaData().getColumnCount();
+            while (resultSet.next()) {
+                for (int i = 1; i <= columnCount; i++) {
+                    print(resultSet.getObject(i));
+                }
+                println();
+            }
+        }
+    }
+