* Default value is {@value tools.jackson.dataformat.csv.impl.CsvEncoder#DEFAULT_MAX_QUOTE_CHECK}.
*
* @param maxChars Maximum number of characters to check; values longer
* than this will always be quoted. Negative values are normalized to
* the default ({@value tools.jackson.dataformat.csv.impl.CsvEncoder#DEFAULT_MAX_QUOTE_CHECK}).
* @return this builder (for call chaining)
*
* @since 3.2
*/
public CsvFactoryBuilder maxQuoteCheckChars(int maxChars) {
_maxQuoteCheckChars = (maxChars >= 0) ? maxChars : CsvEncoder.DEFAULT_MAX_QUOTE_CHECK;
return this;
}
/**
* @return Currently configured maximum quote check length; default
* is {@value tools.jackson.dataformat.csv.impl.CsvEncoder#DEFAULT_MAX_QUOTE_CHECK}.
*
* @since 3.2
*/
public int maxQuoteCheckChars() {
return _maxQuoteCheckChars;
}
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/CsvGenerator.java
================================================
package tools.jackson.dataformat.csv;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import tools.jackson.core.*;
import tools.jackson.core.base.GeneratorBase;
import tools.jackson.core.io.CharacterEscapes;
import tools.jackson.core.json.DupDetector;
import tools.jackson.core.util.SimpleStreamWriteContext;
import tools.jackson.dataformat.csv.impl.CsvEncoder;
import tools.jackson.core.io.IOContext;
import tools.jackson.core.util.JacksonFeatureSet;
public class CsvGenerator extends GeneratorBase
{
protected final static long MIN_INT_AS_LONG = Integer.MIN_VALUE;
protected final static long MAX_INT_AS_LONG = Integer.MAX_VALUE;
private final static CsvSchema EMPTY_SCHEMA = CsvSchema.emptySchema();
/*
/**********************************************************************
/* Configuration
/**********************************************************************
*/
/**
* Bit flag composed of bits that indicate which
* {@link CsvWriteFeature}s
* are enabled.
*/
protected final int _formatFeatures;
/**
* Definition of columns being written, if available.
*/
protected final CsvSchema _schema;
// note: can not be final since we may need to re-create it for new schema
protected CsvEncoder _writer;
/*
/**********************************************************************
/* Output state
/**********************************************************************
*/
/**
* Object that keeps track of the current contextual state of the generator.
*/
protected SimpleStreamWriteContext _streamWriteContext;
/**
* Flag that indicates that we need to write header line, if
* one is needed. Used because schema may be specified after
* instance is constructed.
*/
protected boolean _handleFirstLine = true;
/**
* Index of column that we will be getting next, based on
* the property name call that was made.
*/
protected int _nextColumnByName = -1;
/**
* Decorator to use for decorating the column value to follow, if any;
* {@code null} if none.
*
* @since 2.18
*/
protected CsvValueDecorator _nextColumnDecorator;
/**
* Flag set when property to write is unknown, and the matching value
* is to be skipped quietly.
*/
protected boolean _skipValue;
/**
* Flag set when a row has just been finished, used to distinguish between
* null values within a row vs null rows.
* Only relevant for Array-wrapped rows.
*
* @since 2.21
*/
protected boolean _justFinishedRow = false;
/**
* Separator to use during writing of (simple) array value, to be encoded as a
* single column value, if any.
*/
protected String _arraySeparator = CsvSchema.NO_ARRAY_ELEMENT_SEPARATOR;
/**
* Accumulated contents of an array cell, if any
*/
protected StringBuilder _arrayContents;
/**
* Additional counter that indicates number of value entries in the
* array. Needed because `null` entries do not add content, but need
* to be separated by array cell separator
*/
protected int _arrayElements;
/**
* When skipping output (for "unknown" output), outermost write context
* where skipping should occur
*/
protected SimpleStreamWriteContext _skipWithin;
/*
/**********************************************************************
/* Life-cycle
/**********************************************************************
*/
public CsvGenerator(ObjectWriteContext writeCtxt, IOContext ioCtxt,
int streamWriteFeatures, int csvFeatures,
Writer out, CsvSchema schema, CsvCharacterEscapes characterEscapes,
int maxQuoteCheckChars)
{
super(writeCtxt, ioCtxt, streamWriteFeatures);
_formatFeatures = csvFeatures;
final DupDetector dups = StreamWriteFeature.STRICT_DUPLICATE_DETECTION.enabledIn(streamWriteFeatures)
? DupDetector.rootDetector(this) : null;
_streamWriteContext = SimpleStreamWriteContext.createRootContext(dups);
_schema = schema;
if (characterEscapes == null) {
characterEscapes = CsvCharacterEscapes.fromCsvFeatures(csvFeatures);
}
boolean useFastDoubleWriter = isEnabled(StreamWriteFeature.USE_FAST_DOUBLE_WRITER);
_writer = new CsvEncoder(ioCtxt, csvFeatures, out, schema, characterEscapes,
useFastDoubleWriter, maxQuoteCheckChars);
}
public CsvGenerator(ObjectWriteContext writeCtxt, IOContext ioCtxt,
int streamWriteFeatures, int csvFeatures,
CsvEncoder csvWriter)
{
super(writeCtxt, ioCtxt, streamWriteFeatures);
_formatFeatures = csvFeatures;
final DupDetector dups = StreamWriteFeature.STRICT_DUPLICATE_DETECTION.enabledIn(streamWriteFeatures)
? DupDetector.rootDetector(this) : null;
_streamWriteContext = SimpleStreamWriteContext.createRootContext(dups);
_schema = EMPTY_SCHEMA;
_writer = csvWriter;
}
/*
/**********************************************************************
/* Versioned
/**********************************************************************
*/
@Override
public Version version() {
return PackageVersion.VERSION;
}
/*
/**********************************************************************
/* Overrides: capability introspection methods
/**********************************************************************
*/
@Override
public boolean canOmitProperties() {
// Nope: CSV requires at least a placeholder
return false;
}
@Override
public boolean has(StreamWriteCapability capability) {
return DEFAULT_TEXTUAL_WRITE_CAPABILITIES.isEnabled(capability);
}
@Override
public JacksonFeatureSet
* @param pojoType Type used both for data-binding (result type) and for
* schema introspection. NOTE: must NOT be an array or Collection type, since
* these only make sense for data-binding (like arrays of objects to bind),
* but not for schema construction (no CSV types can be mapped to arrays
* or Collections)
*/
public ObjectReader readerWithSchemaFor(Class pojoType)
{
JavaType type = constructType(pojoType);
/* sanity check: not useful for structured types, since
* schema type will need to differ from data-bind type
*/
if (type.isArrayType() || type.isCollectionLikeType()) {
throw new IllegalArgumentException("Type can NOT be a Collection or array type");
}
return readerFor(type).with(schemaFor(type));
}
/**
* Convenience method which is functionally equivalent to:
*
* @param pojoType Type used both for data-binding (result type) and for
* schema introspection. NOTE: must NOT be an array or Collection type, since
* these only make sense for data-binding (like arrays of objects to bind),
* but not for schema construction (no root-level CSV types can be mapped to arrays
* or Collections)
*/
public ObjectWriter writerWithSchemaFor(Class pojoType)
{
JavaType type = constructType(pojoType);
// sanity check as per javadoc above
if (type.isArrayType() || type.isCollectionLikeType()) {
throw new IllegalArgumentException("Type can NOT be a Collection or array type");
}
return writerFor(type).with(schemaFor(type));
}
/**
* Convenience method which is functionally equivalent to:
*
* NOTE: the column order in the resulting schema is determined by POJO
* property introspection order (which may differ from CSV column order).
* If the schema is used with
* {@link CsvSchema#withHeader() withHeader()} to read CSV data whose
* column order differs from the POJO property order, also enable
* {@link CsvSchema#withColumnReordering(boolean) withColumnReordering(true)}
* so that columns are matched by name rather than position.
*/
public CsvSchema schemaFor(JavaType pojoType) {
return _schemaFor(pojoType, _untypedSchemas, false, null);
}
public CsvSchema schemaForWithView(JavaType pojoType, Class view) {
return _schemaFor(pojoType, _untypedSchemas, false, view);
}
public final CsvSchema schemaFor(Class pojoType) {
return _schemaFor(constructType(pojoType), _untypedSchemas, false, null);
}
public final CsvSchema schemaForWithView(Class pojoType, Class view) {
return _schemaFor(constructType(pojoType), _untypedSchemas, false, view);
}
public final CsvSchema schemaFor(TypeReference pojoTypeRef) {
return _schemaFor(constructType(pojoTypeRef.getType()), _untypedSchemas, false, null);
}
public final CsvSchema schemaForWithView(TypeReference pojoTypeRef, Class view) {
return _schemaFor(constructType(pojoTypeRef.getType()), _untypedSchemas, false, view);
}
/**
* Method that can be used to determine a CSV schema to use for given
* POJO type, using default serialization settings including ordering.
* Definition WILL be strictly typed: that is, code will try to
* determine type limitations which may make parsing more efficient
* (especially for numeric types like java.lang.Integer).
*
* NOTE: the column order in the resulting schema is determined by POJO
* property introspection order (which may differ from CSV column order).
* If the schema is used with
* {@link CsvSchema#withHeader() withHeader()} to read CSV data whose
* column order differs from the POJO property order, also enable
* {@link CsvSchema#withColumnReordering(boolean) withColumnReordering(true)}
* so that columns are matched by name rather than position.
*/
public CsvSchema typedSchemaFor(JavaType pojoType) {
return _schemaFor(pojoType, _typedSchemas, true, null);
}
public CsvSchema typedSchemaForWithView(JavaType pojoType, Class view) {
return _schemaFor(pojoType, _typedSchemas, true, view);
}
public final CsvSchema typedSchemaFor(Class pojoType) {
return _schemaFor(constructType(pojoType), _typedSchemas, true, null);
}
public final CsvSchema typedSchemaForWithView(Class pojoType, Class view) {
return _schemaFor(constructType(pojoType), _typedSchemas, true, view);
}
public final CsvSchema typedSchemaFor(TypeReference pojoTypeRef) {
return _schemaFor(constructType(pojoTypeRef.getType()), _typedSchemas, true, null);
}
public final CsvSchema typedSchemaForWithView(TypeReference pojoTypeRef, Class view) {
return _schemaFor(constructType(pojoTypeRef.getType()), _typedSchemas, true, view);
}
/*
/**********************************************************************
/* Internal methods
/**********************************************************************
*/
protected CsvSchema _schemaFor(JavaType pojoType, SimpleLookupCache
* Implementation is based on a state-machine that pulls information
* using {@link CsvDecoder}.
*/
public class CsvParser
extends ParserMinimalBase
{
// Just to protect against bugs, DoS, limit number of column defs we may read
private final static int MAX_COLUMNS = 99999;
private final static CsvSchema EMPTY_SCHEMA;
static {
EMPTY_SCHEMA = CsvSchema.emptySchema();
}
/**
* CSV is slightly different from defaults, having essentially untyped
* scalars except if indicated by schema
*
* @since 2.12
*/
protected final static JacksonFeatureSet
* In Jackson 2.x this type extends
* {@link tools.jackson.databind.DatabindException}, but for Jackson 3.0
* will become streaming-level exception
*/
public class CsvReadException
extends StreamReadException
{
private static final long serialVersionUID = 3L;
protected final CsvSchema _schema;
public CsvReadException(CsvParser p, String msg, CsvSchema schema) {
super(p, msg);
_schema = schema;
}
public static CsvReadException from(CsvParser p, String msg, CsvSchema schema) {
return new CsvReadException(p, msg, schema);
}
public CsvSchema getSchema() { return _schema; }
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/CsvReadFeature.java
================================================
package tools.jackson.dataformat.csv;
import tools.jackson.core.FormatFeature;
/**
* Enumeration that defines all togglable features for CSV parsers
*
* NOTE: in Jackson 2.x this was named {@code CsvParser.Feature}.
*/
public enum CsvReadFeature
implements FormatFeature
{
/**
* Feature determines whether spaces around separator characters
* (commas) are to be automatically trimmed before being reported
* or not.
* Note that this does NOT force trimming of possible white space from
* within double-quoted values, but only those surrounding unquoted
* values (white space outside of double-quotes is never included regardless
* of trimming).
*
* Default value is false, as per RFC-4180.
*/
TRIM_SPACES(false),
/**
* Feature determines whether spaces around separator characters
* (commas) in header line entries (header names) are to be automatically
* trimmed before being reported or not.
* Note that this does NOT force trimming of possible white space from
* within double-quoted values, but only those surrounding unquoted
* values (white space outside of double-quotes is never included regardless
* of trimming).
*
* Default value is {@code true}.
*/
TRIM_HEADER_SPACES(true),
/**
* Feature that determines how stream of records (usually CSV lines, but sometimes
* multiple lines when line-feeds are included in quoted values) is exposed:
* either as a sequence of Objects (false), or as an Array of Objects (true).
* Using stream of Objects is convenient when using
*
* Default value is false, meaning that by default a CSV document is exposed as
* a sequence of root-level Object entries.
*/
WRAP_AS_ARRAY(false),
/**
* Feature that allows ignoring of unmappable "extra" columns; that is, values for
* columns that appear after columns for which types are defined. When disabled,
* an exception is thrown for such column values, but if enabled, they are
* silently ignored.
*
* Feature is disabled by default.
*/
IGNORE_TRAILING_UNMAPPABLE(false),
/**
* Feature that allows skipping input lines that are completely empty or blank (composed only of whitespace),
* instead of being decoded as lines of just a single column with an empty/blank String value (or,
* depending on binding, `null`).
*
* Feature is disabled by default.
*/
SKIP_EMPTY_LINES(false),
/**
* Feature that allows there to be a trailing single extraneous data
* column that is empty. When this feature is disabled, any extraneous
* column, regardless of content will cause an exception to be thrown.
* Disabling this feature is only useful when
* IGNORE_TRAILING_UNMAPPABLE is also disabled.
*/
ALLOW_TRAILING_COMMA(true),
/**
* Feature that allows accepting "hash comments" by default, similar to
* {@link CsvSchema#withAllowComments(boolean)}. If enabled, such comments
* are by default allowed on all columns of all documents.
*/
ALLOW_COMMENTS(false),
/**
* Feature that allows failing (with a {@link CsvReadException}) in cases
* where number of column values encountered is less than number of columns
* declared in the active schema ("missing columns").
*
* Note that this feature has precedence over {@link #INSERT_NULLS_FOR_MISSING_COLUMNS}
*
* Feature is disabled by default.
*/
FAIL_ON_MISSING_COLUMNS(false),
/**
* Feature that allows failing (with a {@link CsvReadException}) in cases
* where number of header columns encountered is less than number of columns
* declared in the active schema (if there is one).
*
* Feature is enabled by default.
*/
FAIL_ON_MISSING_HEADER_COLUMNS(true),
/**
* Feature that allows "inserting" virtual key / `null` value pairs in case
* a row contains fewer columns than declared by configured schema.
* This typically has the effect of forcing an explicit `null` assigment (or
* corresponding "null value", if so configured) at databinding level.
* If disabled, no extra work is done and values for "missing" columns are
* not exposed as part of the token stream.
*
* Note that this feature is only considered if
* {@link #FAIL_ON_MISSING_COLUMNS}
* is disabled.
*
* Feature is disabled by default.
*/
INSERT_NULLS_FOR_MISSING_COLUMNS(false),
/**
* Feature that enables coercing an empty {@link String} (quoted or unquoted)
* to {@code null}.
*
* Note that if this setting is enabled, {@link #EMPTY_UNQUOTED_STRING_AS_NULL}
* has no effect.
*
* Feature is disabled by default for backwards compatibility.
*/
EMPTY_STRING_AS_NULL(false),
/**
* Feature that enables coercing an empty un-quoted {@link String} to {@code null}.
* This feature allow differentiating between an empty quoted {@link String} and an empty un-quoted {@link String}.
*
* Note that this feature is only considered if
* {@link #EMPTY_STRING_AS_NULL}
* is disabled.
*
* Feature is disabled by default for backwards compatibility.
*/
EMPTY_UNQUOTED_STRING_AS_NULL(false),
/**
* Feature that enables treating empty unquoted cell values as "missing",
* effectively suppressing the token pair (property name + value) for such cells.
* This means that if the target POJO field has a default value, it will be
* preserved instead of being overwritten with an empty String.
*
* This is different from {@link #EMPTY_STRING_AS_NULL} which coerces the value
* to {@code null}: this feature causes the value to not be included in the token
* stream at all, similar to how truly missing columns (row shorter than schema)
* are handled.
*
* Only applies to unquoted empty values; a quoted empty string ({@code ""}) is
* still reported normally.
*
* Feature is disabled by default for backwards compatibility.
*
* @since 3.2
*/
EMPTY_UNQUOTED_STRING_AS_MISSING(false),
/**
* Feature that enables treating only un-quoted values matching the configured
* "null value" String (see {@link CsvSchema#getNullValueString()}) as {@code null},
* but not quoted values:
* differentiating between a quoted null value String (like {@code "null"})
* which remains as a String, and an unquoted null value (like {@code null})
* which becomes {@code null}.
*
* This is similar to {@link #EMPTY_UNQUOTED_STRING_AS_NULL} but applies to the
* explicitly configured null value rather than empty strings.
*
* Note: This feature only has an effect if a null value is configured via
* {@link CsvSchema.Builder#setNullValue(String)}.
*
* Feature is disabled by default for backwards compatibility.
*
* @since 3.1
*/
ONLY_UNQUOTED_NULL_VALUES_AS_NULL(false),
/**
* Feature that allows skipping input rows that consist solely of column separator
* characters (for example, a line containing only {@code ,,} with the default
* comma separator).
* This is different from {@link #SKIP_EMPTY_LINES} which only skips lines that are
* completely empty or blank (whitespace only): this feature skips lines that
* contain only consecutive separator characters followed by a linefeed.
*
* Feature is disabled by default.
*
* @since 3.2
*/
SKIP_EMPTY_ROWS(false),
/**
* Feature that enables failing (with a {@link CsvReadException}) when
* duplicate column names are encountered in the header line.
*
* When enabled, parsing will fail if the header line contains two or more
* columns with the same name. When disabled, duplicates are allowed and
* the last column with a given name will be the one accessible by name
* (earlier columns with the same name are effectively hidden).
*
* Feature is enabled by default.
*
* @since 3.2
*/
FAIL_ON_DUPLICATE_HEADER_COLUMNS(true),
/**
* Feature that enables case-insensitive matching of header column names
* against schema column names. When enabled, a CSV header column named
* "TEMP_MAX" will match a schema column named "temp_max" (and vice versa).
*
* This is useful when used together with
* {@code MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES} to allow
* case-insensitive header matching at the parser level, preventing
* {@link #FAIL_ON_MISSING_HEADER_COLUMNS} from incorrectly reporting
* columns as missing when they differ only by case.
*
* Feature is disabled by default.
*
* @since 3.2
*/
CASE_INSENSITIVE_HEADERS(false),
;
private final boolean _defaultState;
private final int _mask;
/**
* Method that calculates bit set (flags) of all features that
* are enabled by default.
*/
public static int collectDefaults()
{
int flags = 0;
for (CsvReadFeature f : values()) {
if (f.enabledByDefault()) {
flags |= f.getMask();
}
}
return flags;
}
private CsvReadFeature(boolean defaultState) {
_defaultState = defaultState;
_mask = (1 << ordinal());
}
@Override
public boolean enabledByDefault() { return _defaultState; }
@Override
public boolean enabledIn(int flags) { return (flags & _mask) != 0; }
@Override
public int getMask() { return _mask; }
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/CsvSchema.java
================================================
package tools.jackson.dataformat.csv;
import java.util.*;
import java.util.function.UnaryOperator;
import tools.jackson.core.FormatSchema;
/**
* Simple {@link FormatSchema} sub-type that defines properties of
* a CSV document to read or write.
* Instances are thread-safe and immutable.
*
* Properties supported currently are:
*
* Note that schemas without any columns are legal, but if no columns
* are added, behavior of parser/generator is usually different and
* content will be exposed as logical Arrays instead of Objects.
*
* There are 4 ways to create
* Note that this type allows coercion into array, if higher
* level application calls
* {@link tools.jackson.core.JsonParser#isExpectedStartArrayToken},
* unlike more explicit types.
*/
STRING,
/**
* Value is considered to be a String, except that tokens
* "null", "true" and "false" are recognized as matching
* tokens and reported as such;
* and values are trimmed (leading/trailing white space)
*/
STRING_OR_LITERAL,
/**
* Value should be a number, but literals "null", "true" and "false"
* are also understood, and an empty String is considered null.
* Values are also trimmed (leading/trailing white space)
* Other non-numeric Strings may cause parsing exception.
*/
NUMBER,
/**
* Value is taken to be a number (if it matches valid JSON number
* formatting rules), literal (null, true or false) or String,
* depending on best match.
* Values are also trimmed (leading/trailing white space)
*/
NUMBER_OR_STRING,
/**
* Value is expected to be a boolean ("true", "false") String,
* or "null", or empty String (equivalent to null).
* Values are trimmed (leading/trailing white space).
* Values other than indicated above may result in an exception.
*/
BOOLEAN,
/**
* Value will be a multi-value sequence, separated by array element
* separator. Element type itself may be any scalar type (that is, number
* or String) and will not be optimized.
* Separator may be overridden on per-column basis.
*
* Note that this type is used for generic concept of multiple values, and
* not specifically to match Java arrays: data-binding may match such columns
* to {@link java.util.Collection}s as well, or even other types as necessary.
*/
ARRAY,
;
}
/**
* Representation of info for a single column
*/
public static class Column implements java.io.Serializable
{
private static final long serialVersionUID = 1L;
public final static Column PLACEHOLDER = new Column(0, "");
private final String _name;
private final int _index;
private final ColumnType _type;
private final String _arrayElementSeparator;
/**
* Value decorator used for this column, if any; {@code null} if none.
* Used to add decoration on serialization (writing) and remove decoration
* on deserialization (reading).
*/
private final CsvValueDecorator _valueDecorator;
/**
* Link to the next column within schema, if one exists;
* null for the last column.
*/
private final Column _next;
public Column(int index, String name) {
this(index, name, ColumnType.STRING, "");
}
public Column(int index, String name, ColumnType type) {
this(index, name, type, "");
}
public Column(int index, String name, ColumnType type, String arrayElementSep)
{
_index = index;
_name = name;
_type = type;
_arrayElementSeparator = _validArrayElementSeparator(arrayElementSep);
_valueDecorator = null;
_next = null;
}
public Column(Column src, Column next) {
this(src, src._index, src._valueDecorator, next);
}
protected Column(Column src, int index, Column next) {
this(src, index, src._valueDecorator, next);
}
protected Column(Column src, CsvValueDecorator valueDecorator) {
this(src, src._index, valueDecorator, src._next);
}
protected Column(Column src, int index, CsvValueDecorator valueDecorator,
Column next)
{
_index = index;
_name = src._name;
_type = src._type;
_arrayElementSeparator = src._arrayElementSeparator;
_valueDecorator = valueDecorator;
_next = next;
}
public Column withName(String newName) {
if (_name == newName) {
return this;
}
return new Column(_index, newName, _type, _arrayElementSeparator);
}
public Column withType(ColumnType newType) {
if (newType == _type) {
return this;
}
return new Column(_index, _name, newType, _arrayElementSeparator);
}
public Column withArrayElementSeparator(String separator) {
String sep = _validArrayElementSeparator(separator);
if (_arrayElementSeparator.equals(sep)) {
return this;
}
return new Column(_index, _name, _type, sep);
}
public Column withValueDecorator(CsvValueDecorator valueDecorator) {
if (valueDecorator == _valueDecorator) {
return this;
}
return new Column(this, valueDecorator);
}
public Column withNext(Column next) {
if (_next == next) {
return this;
}
return new Column(this, next);
}
public Column withNext(int index, Column next) {
if ((_index == index) && (_next == next)) {
return this;
}
return new Column(this, index, next);
}
public int getIndex() { return _index; }
public String getName() { return _name; }
public ColumnType getType() { return _type; }
public Column getNext() { return _next; }
/**
* Access that returns same as {@link #getNext} iff name of that
* column is same as given name
*/
public Column getNextWithName(String name) {
if (_next != null && name.equals(_next._name)) {
return _next;
}
return null;
}
public boolean hasName(String n) {
return (_name == n) || _name.equals(n);
}
public String getArrayElementSeparator() { return _arrayElementSeparator; }
public CsvValueDecorator getValueDecorator() { return _valueDecorator; }
public boolean isArray() {
return (_type == ColumnType.ARRAY);
}
}
/**
* Class used for building {@link CsvSchema} instances.
*/
public static class Builder
{
protected final ArrayList
* NOTE: this method requires linear scan over existing columns
* so it may be more efficient to use other types of lookups if
* available (for example, {@link CsvSchema#column(String)} has a
* hash lookup to use).
*
* @since 2.9
*/
public boolean hasColumn(String name) {
for (int i = 0, end = _columns.size(); i < end; ++i) {
if (_columns.get(i).getName().equals(name)) {
return true;
}
}
return false;
}
/**
* Method for specifying whether Schema should indicate that
* a header line (first row that contains column names) is to be
* used for reading and writing or not.
*
* NOTE: when the schema already has columns defined, enabling this flag
* alone will cause the header line to be consumed but will NOT reorder
* the schema columns to match the CSV header order — columns are matched
* by position. To match columns by header name instead, also call
* {@link #setReorderColumns(boolean) setReorderColumns(true)}.
*
* @see #setReorderColumns(boolean)
*/
public Builder setUseHeader(boolean b) {
_feature(ENCODING_FEATURE_USE_HEADER, b);
return this;
}
/**
* Use in combination with {@link #setUseHeader(boolean)}. When the use-header
* flag is set, enabling this setting will cause the parser to rebuild the
* schema column order from the actual CSV header line, matching columns
* by name (while preserving their types from the original schema).
* Without this, columns are matched by position only, regardless of header names.
*
* @param b {@code true} to enable column reordering from CSV header,
* {@code false} to disable (default)
* @return This Builder instance
*
* @see #setUseHeader(boolean)
* @since 2.7
*/
public Builder setReorderColumns(boolean b) {
_feature(ENCODING_FEATURE_REORDER_COLUMNS, b);
return this;
}
/**
* Use in combination with {@link #setUseHeader}. When `strict-headers`
* is set, encoder will ensure the headers are in the order
* of the schema; if order differs, an exception is thrown.
*
* @param b Enable / Disable this setting
* @return This Builder instance
*
* @since 2.7
*/
public Builder setStrictHeaders(boolean b) {
_feature(ENCODING_FEATURE_STRICT_HEADERS, b);
return this;
}
/**
* Method for specifying whether Schema should indicate that
* the first line that is not a header (if header handling enabled)
* should be skipped in its entirety.
*/
public Builder setSkipFirstDataRow(boolean b) {
_feature(ENCODING_FEATURE_SKIP_FIRST_DATA_ROW, b);
return this;
}
/**
* Method for specifying whether Schema should indicate that
* "hash comments" (lines where the first non-whitespace character
* is '#') are allowed; if so, they will be skipped without processing.
*
* @since 2.5
*/
public Builder setAllowComments(boolean b) {
_feature(ENCODING_FEATURE_ALLOW_COMMENTS, b);
return this;
}
protected final void _feature(int feature, boolean state) {
_encodingFeatures = state ? (_encodingFeatures | feature) : (_encodingFeatures & ~feature);
}
/**
* Method for specifying character used to separate column
* values.
* Default is comma (',').
*/
public Builder setColumnSeparator(char c) {
_columnSeparator = c;
return this;
}
/**
* Method for specifying character used to separate array element
* values.
* Default value is semicolon (";")
*
* @since 2.7
*/
public Builder setArrayElementSeparator(String separator) {
_arrayElementSeparator = _validArrayElementSeparator(separator);
return this;
}
/**
* @since 2.7
*/
public Builder disableArrayElementSeparator() {
_arrayElementSeparator = NO_ARRAY_ELEMENT_SEPARATOR;
return this;
}
/**
* Method for specifying character used for optional quoting
* of values.
* Default is double-quote ('"').
*/
public Builder setQuoteChar(char c) {
_quoteChar = c;
return this;
}
/**
* @since 2.4
*/
public Builder disableQuoteChar() {
_quoteChar = -1;
return this;
}
/**
* Method for specifying character used for optional escaping
* of characters in quoted String values.
* Default is "not used", meaning that no escaping used.
*/
public Builder setEscapeChar(char c) {
_escapeChar = c;
return this;
}
/**
* Method for specifying that no escape character is to be used
* with CSV documents this schema defines.
*/
public Builder disableEscapeChar() {
_escapeChar = -1;
return this;
}
public Builder setLineSeparator(String lf) {
_lineSeparator = lf.toCharArray();
return this;
}
public Builder setLineSeparator(char lf) {
_lineSeparator = new char[] { lf };
return this;
}
public Builder setNullValue(String nvl) {
return setNullValue((nvl == null) ? null : nvl.toCharArray());
}
public Builder setNullValue(char[] nvl) {
_nullValue = nvl;
return this;
}
public CsvSchema build()
{
Column[] cols = _columns.toArray(new Column[_columns.size()]);
return new CsvSchema(cols, _encodingFeatures,
_columnSeparator, _quoteChar, _escapeChar,
_lineSeparator, _arrayElementSeparator,
_nullValue, _anyPropertyName);
}
protected void _checkIndex(int index) {
if (index < 0 || index >= _columns.size()) {
throw new IllegalArgumentException("Illegal index "+index+"; only got "+_columns.size()+" columns");
}
}
}
/*
/**********************************************************************
/* Configuration, construction
/**********************************************************************
*/
/**
* Column definitions, needed for optional header and/or mapping
* of field names to column positions.
*/
protected final Column[] _columns;
protected final Map
* When this is enabled (and the schema uses a header line), the parser will
* rebuild the column ordering from the actual CSV header, matching columns
* by name against those defined in the schema (preserving their types).
* This allows parsing CSV files whose column order differs from the order
* in which columns were defined in the schema (for example, via
* {@link CsvMapper#schemaFor(Class)}).
*
* When disabled (the default), columns are matched by position only:
* the first CSV value maps to the first schema column, the second to the
* second, and so on — regardless of what the header names say.
*
* @param state {@code true} to enable column reordering from CSV header,
* {@code false} to disable (default)
* @return A copy of this schema with the updated setting
*
* @see #withHeader()
* @since 2.7
*/
public CsvSchema withColumnReordering(boolean state) {
return _withFeature(ENCODING_FEATURE_REORDER_COLUMNS, state);
}
/**
* Returns a clone of this instance by changing or setting the
* strict headers flag
*
* @param state New value for setting
* @return A copy of itself, ensuring the setting for
* the strict headers feature.
* @since 2.7
*/
public CsvSchema withStrictHeaders(boolean state) {
return _withFeature(ENCODING_FEATURE_STRICT_HEADERS, state);
}
/**
* Helper method for constructing and returning schema instance that
* is similar to this one, except that it will be using header line
* (first row of CSV content used for reading and/or writing column names).
*<p>
* NOTE: when this schema already has columns defined (for example, via
* {@link CsvMapper#schemaFor(Class)}), and the CSV input has a header line
* with columns in a different order than defined in the schema, columns
* will be matched by their position in the schema — not by
* the header names — unless {@link #withColumnReordering(boolean)} is
* also enabled. Without column reordering, the header line is consumed
* (validated or skipped) but does NOT change the column order of the schema.
* This can lead to values being mapped to wrong properties if the CSV column
* order differs from the schema column order.
*
* To use header names for column matching regardless of order, call:
*
* As with all `withXxx()` methods this method never modifies `this` but either
* returns it unmodified (if no new columns found from `toAppend`), or constructs
* a new instance and returns that.
*
* @return Either this schema (if nothing changed), or newly constructed {@link CsvSchema}
* with appended columns.
*
* @since 2.9
*/
public CsvSchema withColumnsFrom(CsvSchema toAppend) {
int addCount = toAppend.size();
if (addCount == 0) {
return this;
}
Builder b = rebuild();
for (int i = 0; i < addCount; ++i) {
Column col = toAppend.column(i);
if (column(col.getName()) == null) {
b.addColumn(col);
}
}
return b.build();
}
/**
* Mutant factory method that will try to replace specified column with
* changed definition (but same name), leaving other columns as-is.
*
* As with all `withXxx()` methods this method never modifies `this` but either
* returns it unmodified (if no change to column), or constructs
* a new schema instance and returns that.
*
* @param columnName Name of column to replace
* @param transformer Transformation to apply to the column
*
* @return Either this schema (if column did not change), or newly constructed {@link CsvSchema}
* with changed column
*
* @since 2.18
*/
public CsvSchema withColumn(String columnName, UnaryOperator
* As with all `withXxx()` methods this method never modifies `this` but either
* returns it unmodified (if no change to column), or constructs
* a new schema instance and returns that.
*
* @param columnIndex Index of column to replace
* @param transformer Transformation to apply to the column
*
* @return Either this schema (if column did not change), or newly constructed {@link CsvSchema}
* with changed column
*
* @since 2.18
*/
public CsvSchema withColumn(int columnIndex, UnaryOperator
* For example, schema that has columns:
*
* Decorations are handled after handling other encoding aspects such as
* optional quoting and/or escaping.
*
* Decorators can be registered on specific columns of {@link CsvSchema}.
*
* @since 2.18
*/
public interface CsvValueDecorator
{
/**
* Method called during serialization when encoding a value,
* to produce "decorated" value to include in output (possibly
* escaped and/or quoted).
* Note that possible escaping and/or quoting (as per configuration
* of {@link CsvSchema} is applied on decorated value.
*
* @param gen Generator that will be used for actual serialization
* @param plainValue Value to decorate
*
* @return Decorated value (which may be {@code plainValue} as-is) but
* Must Not be {@code null}
*
* @throws JacksonException if attempt to decorate the value somehow fails
*/
public String decorateValue(CsvGenerator gen, String plainValue)
throws JacksonException;
/**
* Method called instead of {@link #decorateValue} in case where value being
* written is from Java {@code null} value: this is often left as-is, without
* decoration (and this is the default implementation), but may be
* decorated.
* To let default Null Value Replacement be used, should return {@code null}:
* this is the default implementation.
*
* @param gen Generator that will be used for actual serialization
*
* @return Decorated value to use, IF NOT {@code null}: if {@code null} will use
* default null replacement value.
*
* @throws JacksonException if attempt to decorate the value somehow fails
*/
public default String decorateNull(CsvGenerator gen)
throws JacksonException
{
return null;
}
/**
* Method called during deserialization, to remove possible decoration
* applied with {@link #decorateValue}.
* Call is made after textual value for a cell (column
* value) has been read using {@code parser} and after removing (decoding)
* possible quoting and/or escaping of the value. Value passed in
* has no escaping or quoting left.
*
* @param parser Parser that was used to decode textual value from input
* @param decoratedValue Value from which to remove decorations, if any
* (some decorators can allow optional decorations; others may fail
* if none found)
*
* @return Value after removing decorations, if any.
*
* @throws JacksonException if attempt to un-decorate the value fails
*/
public String undecorateValue(CsvParser parser, String decoratedValue)
throws JacksonException;
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/CsvValueDecorators.java
================================================
package tools.jackson.dataformat.csv;
import java.util.Objects;
import tools.jackson.core.JacksonException;
/**
* Container class for default {@link CsvValueDecorator} implementations
*
* @since 2.18
*/
public class CsvValueDecorators
{
/**
* {@link StringPrefixSuffixDecorator} that uses square brackets ({@code []})
* around decorated value, but does not require their use (removes if used,
* ignores it not).
*/
public final static CsvValueDecorator OPTIONAL_BRACKETS_DECORATOR
= new StringPrefixSuffixDecorator("[", "]", true);
/**
* {@link StringPrefixSuffixDecorator} that uses square brackets ({@code []})
* around decorated value, and requires their use (if value has no matching
* decoration, an exception is thrown when attempting to read the value).
*/
public final static CsvValueDecorator STRICT_BRACKETS_DECORATOR
= new StringPrefixSuffixDecorator("[", "]", false);
/**
* Factory method for constructing a {@link StringPrefixSuffixDecorator} with
* given prefix and suffix, both optional.
*/
public static CsvValueDecorator optionalPrefixSuffixDecorator(String prefix, String suffix) {
return new StringPrefixSuffixDecorator(prefix, suffix, true);
}
/**
* Factory method for constructing a {@link StringPrefixSuffixDecorator} with
* given prefix and suffix, both required.
*/
public static CsvValueDecorator requiredPrefixSuffixDecorator(String prefix, String suffix) {
return new StringPrefixSuffixDecorator(prefix, suffix, false);
}
/**
* Decorated that adds static prefix and suffix around value to decorate value;
* removes the same when un-decorating. Handling of the case where decoration
* is missing on deserialization (reading) depends on where decorator is
* created with "optional" or "strict" setting
* (see {@link StringPrefixSuffixDecorator#StringPrefixSuffixDecorator}).
*/
public static class StringPrefixSuffixDecorator
implements CsvValueDecorator
{
/**
* Decoration added before value being decorated: for example, if decorating
* with brackets, this would be opening bracket {@code [ }.
*/
protected final String _prefix;
/**
* Decoration added after value being decorated: for example, if decorating
* with brackets, this would be closing bracket {@code ] }.
*/
protected final String _suffix;
/**
* Whether existence of prefix and suffix decoration is optional
* ({@code true}) or required ({@code false}): if required
* and value does does not have decorations, deserialization (reading)
* will fail with an exception; if optional value is exposed as is.
*/
protected final boolean _optional;
public StringPrefixSuffixDecorator(String prefix, String suffix, boolean optional) {
_prefix = Objects.requireNonNull(prefix);
_suffix = Objects.requireNonNull(suffix);
_optional = optional;
}
@Override
public String decorateValue(CsvGenerator gen, String plainValue) throws JacksonException {
return new StringBuilder(plainValue.length() + _prefix.length() + _suffix.length())
.append(_prefix)
.append(plainValue)
.append(_suffix)
.toString()
;
}
@Override
public String undecorateValue(CsvParser parser, String decoratedValue) throws JacksonException {
if (!decoratedValue.startsWith(_prefix)) {
if (!_optional) {
parser._reportCsvReadError(String.format(
"Decorated value of column '%s' does not start with expected prefix (\"%s\"); value: \"%s\"",
parser.currentName(), _prefix, decoratedValue));
}
return decoratedValue;
}
if (!decoratedValue.endsWith(_suffix)) {
if (!_optional) {
parser._reportCsvReadError(String.format(
"Decorated value of column '%s' does not end with expected suffix (\"%s\"); value: \"%s\"",
parser.currentName(), _suffix, decoratedValue));
}
return decoratedValue;
}
int start = _prefix.length();
int end = decoratedValue.length() - _suffix.length();
// One minor complication: suffix and prefix could overlap
if (start >= end) {
return "";
}
return decoratedValue.substring(start, end);
}
}
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/CsvWriteException.java
================================================
package tools.jackson.dataformat.csv;
import tools.jackson.core.exc.StreamWriteException;
/**
* Format-specific exception used to indicate problems regarding low-level
* generation issues specific to CSV content;
* usually problems with field-to-column mapping as defined by {@link CsvSchema}.
*/
public class CsvWriteException
extends StreamWriteException
{
private static final long serialVersionUID = 3L;
protected final CsvSchema _schema;
public CsvWriteException(CsvGenerator gen, String msg, CsvSchema schema) {
super(gen, msg);
_schema = schema;
}
public static CsvWriteException from(CsvGenerator gen, String msg, CsvSchema schema) {
return new CsvWriteException(gen, msg, schema);
}
public CsvSchema getSchema() { return _schema; }
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/CsvWriteFeature.java
================================================
package tools.jackson.dataformat.csv;
import tools.jackson.core.FormatFeature;
/**
* Enumeration that defines all togglable features for CSV writers
*
* NOTE: in Jackson 2.x this was named {@code CsvGenerator.Feature}.
*/
public enum CsvWriteFeature
implements FormatFeature
{
/**
* Feature that determines how much work is done before determining that
* a column value requires quoting: when set as
* Note, however, that regardless setting, all values that need to be quoted
* will be: it is just that when set to {@code false}, other values may
* also be quoted (to avoid having to do more expensive checks).
*
* Default value is {@code false} for "loose" (approximate, conservative)
* checking.
*/
STRICT_CHECK_FOR_QUOTING(false),
/**
* Feature that determines whether columns without matching value may be omitted,
* when they are the last values of the row.
* If {@code true}, values and separators between values may be omitted, to slightly reduce
* length of the row; if {@code false}, separators need to stay in place and values
* are indicated by empty Strings.
*/
OMIT_MISSING_TAIL_COLUMNS(false),
/**
* Feature that determines whether values written as Strings (from
* Default value is {@code false} so that leading/trailing whitespace
* does not by itself trigger quoting.
*
* @since 3.2
*/
QUOTE_STRINGS_WITH_LEADING_TRAILING_WHITESPACE(false),
/**
* Feature that determines whether values written as Nymbers (from {@code java.lang.Number}
* valued POJO properties) should be forced to be quoted, regardless of whether they
* actually need this.
*/
ALWAYS_QUOTE_NUMBERS(false),
/**
* Feature that determines whether quote characters within quoted String values are escaped
* using configured escape character, instead of being "doubled up" (that is: a quote character
* is written twice in a row).
*
* Default value is false so that quotes are doubled as necessary, not escaped.
*/
ESCAPE_QUOTE_CHAR_WITH_ESCAPE_CHAR(false),
/**
* Feature that determines whether control characters (non-printable) are escaped using the
* configured escape character. This feature allows LF and CR characters to be output as
* Default value is false so that control characters are echoed out (backwards compatible).
*/
ESCAPE_CONTROL_CHARS_WITH_ESCAPE_CHAR(false),
/**
* Feature that determines whether a line-feed will be written at the end of content,
* after the last row of output.
*
* NOTE! When disabling this feature it is important that
* {@link CsvGenerator#flush()} is NOT called before {@link CsvGenerator#close()} is called;
* the current implementation relies on ability to essentially remove the
* last linefeed that was appended in the output buffer.
*
* Default value is {@code true} so all rows, including the last, are terminated by
* a line feed.
*/
WRITE_LINEFEED_AFTER_LAST_ROW(true)
;
private final boolean _defaultState;
private final int _mask;
/**
* Method that calculates bit set (flags) of all features that
* are enabled by default.
*/
public static int collectDefaults()
{
int flags = 0;
for (CsvWriteFeature f : values()) {
if (f.enabledByDefault()) {
flags |= f.getMask();
}
}
return flags;
}
private CsvWriteFeature(boolean defaultState) {
_defaultState = defaultState;
_mask = (1 << ordinal());
}
@Override
public boolean enabledIn(int flags) { return (flags & _mask) != 0; }
@Override
public boolean enabledByDefault() { return _defaultState; }
@Override
public int getMask() { return _mask; }
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/PackageVersion.java.in
================================================
package @package@;
import tools.jackson.core.Version;
import tools.jackson.core.Versioned;
import tools.jackson.core.util.VersionUtil;
/**
* Automatically generated from PackageVersion.java.in during
* packageVersion-generate execution of maven-replacer-plugin in
* pom.xml.
*/
public final class PackageVersion implements Versioned {
public final static Version VERSION = VersionUtil.parseVersion(
"@projectversion@", "@projectgroupid@", "@projectartifactid@");
@Override
public Version version() {
return VERSION;
}
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/impl/BufferedValue.java
================================================
package tools.jackson.dataformat.csv.impl;
import tools.jackson.core.JacksonException;
/**
* Helper class used for holding values for a while until output
* can proceed in expected order.
*/
public abstract class BufferedValue
{
protected BufferedValue() { }
public abstract void write(CsvEncoder w) throws JacksonException;
public static BufferedValue buffered(String v) { return new TextValue(v); }
public static BufferedValue bufferedRaw(String v) { return new RawValue(v); }
public static BufferedValue buffered(int v) { return new IntValue(v); }
public static BufferedValue buffered(long v) { return new LongValue(v); }
public static BufferedValue buffered(float v) { return new FloatValue(v); }
public static BufferedValue buffered(double v) { return new DoubleValue(v); }
public static BufferedValue bufferedNumber(String numStr) { return new BigNumberValue(numStr); }
public static BufferedValue buffered(boolean v) {
return v ? BooleanValue.TRUE : BooleanValue.FALSE;
}
public static BufferedValue bufferedNull() {
return NullValue.std;
}
protected final static class TextValue extends BufferedValue
{
private final String _value;
public TextValue(String v) { _value = v; }
@Override
public void write(CsvEncoder w) throws JacksonException {
w.appendValue(_value);
}
}
/**
* @since 2.5
*/
protected final static class RawValue extends BufferedValue
{
private final String _value;
public RawValue(String v) { _value = v; }
@Override
public void write(CsvEncoder w) throws JacksonException {
w.appendRawValue(_value);
}
}
protected final static class IntValue extends BufferedValue
{
private final int _value;
public IntValue(int v) { _value = v; }
@Override
public void write(CsvEncoder w) throws JacksonException {
w.appendValue(_value);
}
}
protected final static class LongValue extends BufferedValue
{
private final long _value;
public LongValue(long v) { _value = v; }
@Override
public void write(CsvEncoder w) throws JacksonException {
w.appendValue(_value);
}
}
// @since 2.16
protected final static class FloatValue extends BufferedValue
{
private final float _value;
public FloatValue(float v) { _value = v; }
@Override
public void write(CsvEncoder w) throws JacksonException {
w.appendValue(_value);
}
}
protected final static class DoubleValue extends BufferedValue
{
private final double _value;
public DoubleValue(double v) { _value = v; }
@Override
public void write(CsvEncoder w) throws JacksonException {
w.appendValue(_value);
}
}
protected final static class BigNumberValue extends BufferedValue
{
private final String _value;
public BigNumberValue(String v) { _value = v; }
@Override
public void write(CsvEncoder w) throws JacksonException {
w.appendNumberValue(_value);
}
}
protected final static class BooleanValue extends BufferedValue
{
public final static BooleanValue FALSE = new BooleanValue(false);
public final static BooleanValue TRUE = new BooleanValue(true);
private final boolean _value;
public BooleanValue(boolean v) { _value = v; }
@Override
public void write(CsvEncoder w) throws JacksonException {
w.appendValue(_value);
}
}
protected final static class NullValue extends BufferedValue {
public final static NullValue std = new NullValue();
private NullValue() { }
@Override
public void write(CsvEncoder w) throws JacksonException {
w.appendNull();
}
}
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/impl/CsvDecoder.java
================================================
package tools.jackson.dataformat.csv.impl;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;
import tools.jackson.core.*;
import tools.jackson.core.JsonParser.NumberType;
import tools.jackson.core.StreamReadFeature;
import tools.jackson.core.exc.StreamReadException;
import tools.jackson.core.io.NumberInput;
import tools.jackson.core.io.IOContext;
import tools.jackson.core.util.SimpleStreamReadContext;
import tools.jackson.core.util.TextBuffer;
import tools.jackson.dataformat.csv.CsvParser;
import tools.jackson.dataformat.csv.CsvReadFeature;
import tools.jackson.dataformat.csv.CsvSchema;
/**
* Low-level helper class that handles actual reading of CSV,
* purely based on indexes given without worrying about reordering etc.
*/
public class CsvDecoder
{
private final static int INT_SPACE = 0x0020;
private final static int INT_CR = '\r';
private final static int INT_LF = '\n';
/*
/**********************************************************************
/* Input handling, configuration
/**********************************************************************
*/
/**
* Unfortunate back reference, needed for error reporting
*/
protected final CsvParser _owner;
/**
* I/O context for this reader. It handles buffer allocation
* for the reader.
*/
protected final IOContext _ioContext;
/**
* Input stream that can be used for reading more content, if one
* in use. May be null, if input comes just as a full buffer,
* or if the stream has been closed.
*
* NOTE: renamed in 2.13 from {@code _inputSource}.
*/
protected Reader _inputReader;
/**
* Flag that indicates whether the input buffer is recycable (and
* needs to be returned to recycler once we are done) or not.
*
* If it is not, it also means that parser can NOT modify underlying
* buffer.
*/
protected boolean _bufferRecyclable;
protected boolean _autoCloseInput;
/**
* Configuration flag that determines whether spaces surrounding
* separator characters are to be automatically trimmed or not.
*/
protected boolean _trimSpaces;
protected boolean _allowComments;
protected boolean _skipBlankLines;
protected boolean _skipEmptyRows;
/**
* Number of separator characters consumed by {@link #_trySkipEmptyRow()} when
* a row starting with separators turns out to contain non-empty values.
* These consumed separators are replayed as empty String values by
* {@link #nextString()}.
*
* @since 3.2
*/
protected int _pendingEmptyColumns;
/**
* Maximum of quote character, linefeeds (\r and \n), escape character.
*/
protected int _maxSpecialChar;
protected int _separatorChar;
protected int _quoteChar;
protected int _escapeChar;
/*
/**********************************************************************
/* Input handling, state
/**********************************************************************
*/
/**
* Buffer that contains contents of all values after processing
* of doubled-quotes, escaped characters.
*/
protected final TextBuffer _textBuffer;
/**
* Current buffer from which data is read; generally data is read into
* buffer from input source, but in some cases pre-loaded buffer
* is handed to the parser.
*/
protected char[] _inputBuffer;
/**
* Pointer to next available character in buffer
*/
protected int _inputPtr = 0;
/**
* Index of character after last available one in the buffer.
*/
protected int _inputEnd = 0;
/**
* Lazily-allocated buffer for tracking leading whitespace consumed
* while looking ahead for a quote character ([dataformats-text#643]).
* Reused across calls to avoid repeated allocation.
*
* @since 3.2
*/
protected char[] _leadingSpaceBuf;
/**
* Marker to indicate that a linefeed was encountered and now
* needs to be handled (indicates end-of-record).
*/
protected int _pendingLF = 0;
/**
* Flag that indicates whether parser is closed or not. Gets
* set when parser is either closed by explicit call
* ({@link #close}) or when end-of-input is reached.
*/
protected boolean _closed;
/*
/**********************************************************************
/* Current input location information
/**********************************************************************
*/
/**
* Number of characters/bytes that were contained in previous blocks
* (blocks that were already processed prior to the current buffer).
*/
protected long _currInputProcessed = 0L;
/**
* Current row location of current point in input buffer, starting
* from 1, if available.
*/
protected int _currInputRow = 1;
/**
* Current index of the first character of the current row in input
* buffer. Needed to calculate column position, if necessary; benefit
* of not having column itself is that this only has to be updated
* once per line.
*/
protected int _currInputRowStart = 0;
/**
* Flag that indicates whether the current token has been quoted or not.
*
* @since 2.18
*/
protected boolean _currInputQuoted = false;
// // // Location info at point when current token was started
/**
* Total number of bytes/characters read before start of current token.
* For big (gigabyte-sized) sizes are possible, needs to be long,
* unlike pointers and sizes related to in-memory buffers.
*/
protected long _tokenInputTotal = 0;
/**
* Input row on which current token starts, 1-based
*/
protected int _tokenInputRow = 1;
/**
* Column on input row that current token starts; 0-based (although
* in the end it'll be converted to 1-based)
*/
protected int _tokenInputCol = 0;
/*
/**********************************************************************
/* Constants and fields of former 'JsonNumericParserBase'
/**********************************************************************
*/
final protected static int NR_UNKNOWN = 0;
// First, integer types
final protected static int NR_INT = 0x0001;
final protected static int NR_LONG = 0x0002;
final protected static int NR_BIGINT = 0x0004;
// And then floating point types
final protected static int NR_DOUBLE = 0x008;
final protected static int NR_BIGDECIMAL = 0x0010;
// Also, we need some numeric constants (copied from ParserBase)
final static BigInteger BI_MIN_INT = BigInteger.valueOf(Integer.MIN_VALUE);
final static BigInteger BI_MAX_INT = BigInteger.valueOf(Integer.MAX_VALUE);
final static BigInteger BI_MIN_LONG = BigInteger.valueOf(Long.MIN_VALUE);
final static BigInteger BI_MAX_LONG = BigInteger.valueOf(Long.MAX_VALUE);
final static BigDecimal BD_MIN_LONG = new BigDecimal(Long.MIN_VALUE);
final static BigDecimal BD_MAX_LONG = new BigDecimal(Long.MAX_VALUE);
final static BigDecimal BD_MIN_INT = new BigDecimal(Long.MIN_VALUE);
final static BigDecimal BD_MAX_INT = new BigDecimal(Long.MAX_VALUE);
final static long MIN_INT_L = Integer.MIN_VALUE;
final static long MAX_INT_L = Integer.MAX_VALUE;
// These are not very accurate, but have to do... (for bounds checks)
final static double MIN_LONG_D = Long.MIN_VALUE;
final static double MAX_LONG_D = Long.MAX_VALUE;
final static double MIN_INT_D = Integer.MIN_VALUE;
final static double MAX_INT_D = Integer.MAX_VALUE;
// Digits, numeric
final protected static int INT_0 = '0';
final protected static int INT_1 = '1';
final protected static int INT_2 = '2';
final protected static int INT_3 = '3';
final protected static int INT_4 = '4';
final protected static int INT_5 = '5';
final protected static int INT_6 = '6';
final protected static int INT_7 = '7';
final protected static int INT_8 = '8';
final protected static int INT_9 = '9';
final protected static int INT_MINUS = '-';
final protected static int INT_PLUS = '+';
final protected static int INT_DECIMAL_POINT = '.';
final protected static int INT_e = 'e';
final protected static int INT_E = 'E';
final protected static char CHAR_NULL = '\0';
// Numeric value holders: multiple fields used for
// for efficiency
/**
* Bitfield that indicates which numeric representations
* have been calculated for the current type
*/
protected int _numTypesValid = NR_UNKNOWN;
// First primitives
protected int _numberInt;
protected long _numberLong;
protected double _numberDouble;
// And then object types
protected BigInteger _numberBigInt;
protected BigDecimal _numberBigDecimal;
/**
* Textual number representation captured from input in cases lazy-parsing
* is desired.
*
* As of 2.14, this only applies to {@link BigInteger} and {@link BigDecimal}.
*
* @since 2.14
*/
protected String _numberString;
/*
/**********************************************************************
/* Life-cycle
/**********************************************************************
*/
public CsvDecoder(IOContext ctxt, CsvParser owner, Reader r,
CsvSchema schema, TextBuffer textBuffer,
int stdFeatures, int csvFeatures)
{
_owner = owner;
_ioContext = ctxt;
_inputReader = r;
_textBuffer = textBuffer;
_autoCloseInput = StreamReadFeature.AUTO_CLOSE_SOURCE.enabledIn(stdFeatures);
_allowComments = CsvReadFeature.ALLOW_COMMENTS.enabledIn(csvFeatures);
_trimSpaces = CsvReadFeature.TRIM_SPACES.enabledIn(csvFeatures);
_skipBlankLines = CsvReadFeature.SKIP_EMPTY_LINES.enabledIn(csvFeatures);
_skipEmptyRows = CsvReadFeature.SKIP_EMPTY_ROWS.enabledIn(csvFeatures);
_inputBuffer = ctxt.allocTokenBuffer();
_bufferRecyclable = true; // since we allocated it
_tokenInputRow = -1;
_tokenInputCol = -1;
setSchema(schema);
}
public void setSchema(CsvSchema schema) {
_separatorChar = schema.getColumnSeparator();
_quoteChar = schema.getQuoteChar();
_escapeChar = schema.getEscapeChar();
if (!_allowComments) {
_allowComments = schema.allowsComments();
}
int max = Math.max(_separatorChar, _quoteChar);
max = Math.max(max, _escapeChar);
max = Math.max(max, '\r');
max = Math.max(max, '\n');
_maxSpecialChar = max;
}
/*
/**********************************************************************
/* JsonParser implementations passed-through by CsvParser
/**********************************************************************
*/
public Object getInputSource() {
return _inputReader;
}
public void close() throws IOException {
_pendingLF = 1; // just to ensure we'll also check _closed flag later on
if (!_closed) {
_closed = true;
try {
_closeInput();
} finally {
// Also, internal buffer(s) can now be released as well
releaseBuffers();
}
}
}
public int releaseBuffered(Writer out) throws IOException {
int count = _inputEnd - _inputPtr;
if (count < 1) {
return 0;
}
// let's just advance ptr to end
int origPtr = _inputPtr;
out.write(_inputBuffer, origPtr, count);
return count;
}
public SimpleStreamReadContext childArrayContext(SimpleStreamReadContext context) {
int col = _inputPtr - _currInputRowStart + 1; // 1-based
return context.createChildArrayContext(_currInputRow, col);
}
public SimpleStreamReadContext childObjectContext(SimpleStreamReadContext context) {
int col = _inputPtr - _currInputRowStart + 1; // 1-based
return context.createChildObjectContext(_currInputRow, col);
}
public TokenStreamLocation getTokenLocation()
{
return new TokenStreamLocation(_ioContext.contentReference(),
getTokenCharacterOffset(),
getTokenLineNr(), getTokenColumnNr());
}
public TokenStreamLocation getCurrentLocation() {
int ptr = _inputPtr;
// One twist: when dealing with a "pending LF", need to
// go back one position when calculating location
if (_pendingLF > 1) { // 1 is used as marker for end-of-input
--ptr;
}
int col = ptr - _currInputRowStart + 1; // 1-based
return new TokenStreamLocation(_ioContext.contentReference(),
_currInputProcessed + ptr - 1L, _currInputRow, col);
}
public final int getCurrentRow() {
return _currInputRow;
}
public final int getCurrentColumn() {
int ptr = _inputPtr;
// One twist: when dealing with a "pending LF", need to
// go back one position when calculating location
if (_pendingLF > 1) { // 1 is used as marker for end-of-input
--ptr;
}
return ptr - _currInputRowStart + 1; // 1-based
}
/**
* Tell if the current token has been quoted or not.
* @return True if the current token has been quoted, false otherwise
*
* @since 2.18
*/
public final boolean isCurrentTokenQuoted() {
return _currInputQuoted;
}
/*
/**********************************************************************
/* Helper methods, input handling
/**********************************************************************
*/
protected final long getTokenCharacterOffset() {
return _tokenInputTotal;
}
protected final int getTokenLineNr() {
return _tokenInputRow;
}
protected final int getTokenColumnNr() {
// note: value of -1 means "not available"; otherwise convert from 0-based to 1-based
int col = _tokenInputCol;
return (col < 0) ? col : (col + 1);
}
protected void releaseBuffers() throws JacksonException {
_textBuffer.releaseBuffers();
char[] buf = _inputBuffer;
if (buf != null) {
_inputBuffer = null;
_ioContext.releaseTokenBuffer(buf);
}
}
protected void _closeInput() throws IOException {
_pendingLF = 1; // just to ensure we'll also check _closed flag later on
/* 25-Nov-2008, tatus: As per [JACKSON-16] we are not to call close()
* on the underlying Reader, unless we "own" it, or auto-closing
* feature is enabled.
* One downside is that when using our optimized
* Reader (granted, we only do that for UTF-32...) this
* means that buffer recycling won't work correctly.
*/
if (_inputReader != null) {
if (_autoCloseInput || _ioContext.isResourceManaged()) {
_inputReader.close();
}
_inputReader = null;
}
}
protected final boolean loadMore() throws JacksonException {
_currInputProcessed += _inputEnd;
_currInputRowStart -= _inputEnd;
// [dataformats-text#613]: enforce max document length
_ioContext.streamReadConstraints().validateDocumentLength(_currInputProcessed);
try {
if (_inputReader != null) {
int count = _inputReader.read(_inputBuffer, 0, _inputBuffer.length);
_inputEnd = count;
_inputPtr = 0;
if (count > 0) {
return true;
}
// End of input; close here -- but note, do NOT yet call releaseBuffers()
// as there may be buffered input to handle
_closeInput();
// Should never return 0, so let's fail
if (count == 0) {
throw new IOException("InputStream.read() returned 0 characters when trying to read "+_inputBuffer.length+" bytes");
}
}
} catch (IOException e) {
throw _owner._wrapIOFailure(e);
}
return false;
}
/*
/**********************************************************************
/* Actual parsing, access methods
/**********************************************************************
*/
public String getText() throws JacksonException {
return _textBuffer.contentsAsString();
}
/**
* Method that can be called to see if there is at least one more
* character to be parsed.
*/
public boolean hasMoreInput() throws JacksonException {
if (_inputPtr < _inputEnd) {
return true;
}
return loadMore();
}
/**
* Method called to handle details of starting a new line, which may
* include skipping a linefeed.
*
* @return True if there is a new data line to handle; false if not
*/
public boolean startNewLine() throws JacksonException {
_pendingEmptyColumns = 0;
// first: if pending LF, skip it
if (_pendingLF != 0) {
if (_inputReader == null) {
return false;
}
_handleLF();
}
return skipLinesWhenNeeded();
}
/**
* Optionally skip lines that are empty or are comments, depending on the feature activated in the parser
*
* @return false if the end of input was reached
* @throws JacksonException
*/
public boolean skipLinesWhenNeeded() throws JacksonException {
if (_allowComments) {
return _skipCommentLines();
}
if (!_skipBlankLines && !_skipEmptyRows) {
return hasMoreInput();
}
// only need to skip fully empty lines (and optionally empty rows)
while (hasMoreInput()) {
char ch = _inputBuffer[_inputPtr];
if (ch == '\r' || ch == '\n') {
++_inputPtr;
_pendingLF = ch;
_handleLF();
continue;
}
if (ch == ' ' && _skipBlankLines) {
++_inputPtr;
continue;
}
// [dataformats-text#368]: Row of only separator characters?
if (_skipEmptyRows && ch == _separatorChar) {
if (_trySkipEmptyRow()) {
continue;
}
}
return true; // processing can go on
}
return false; // end of input
}
public boolean _skipCommentLines() throws JacksonException
{
while ((_inputPtr < _inputEnd) || loadMore()) {
char ch = _inputBuffer[_inputPtr];
switch (ch) {
case '#':
++_inputPtr;
_skipCommentContents();
continue;
case '\r':
case '\n':
++_inputPtr;
_pendingLF = ch;
_handleLF();
continue;
case ' ':
// skip all blanks (in both comments/blanks skip mode)
++_inputPtr;
continue;
default:
// [dataformats-text#368]: Check if line consists only of separators
if (_skipEmptyRows && ch == _separatorChar) {
if (_trySkipEmptyRow()) {
continue;
}
}
return true;
}
}
return false; // end of input
}
protected void _skipCommentContents() throws JacksonException
{
while ((_inputPtr < _inputEnd) || loadMore()) {
char ch = _inputBuffer[_inputPtr++];
if (ch == '\r' || ch == '\n') {
_pendingLF = ch;
_handleLF();
break;
}
}
}
/**
* Helper method called when we see a separator character at the start of a line
* and need to determine if the entire row consists only of consecutive separator
* characters (no other content) followed by a linefeed or EOF.
*
* Consumes separator characters one at a time. If a linefeed or EOF is reached,
* the row is empty and is skipped (returns {@code true}). If any other character
* is found, the consumed separators are recorded in {@link #_pendingEmptyColumns}
* so that {@link #nextString()} can replay them as empty values.
*
* @return {@code true} if the row was determined to be empty and was skipped;
* {@code false} if the row contains non-empty content (consumed separators
* will be replayed via {@link #_pendingEmptyColumns})
*/
protected boolean _trySkipEmptyRow() throws JacksonException
{
int separatorCount = 0;
while (true) {
// Consume the separator character at current position
++_inputPtr;
++separatorCount;
// Need more input?
if (_inputPtr >= _inputEnd) {
if (!loadMore()) {
// EOF after separators only: empty row at end of input
return true;
}
}
char ch = _inputBuffer[_inputPtr];
if (ch == _separatorChar) {
continue;
}
if (ch == '\r' || ch == '\n') {
// Row consisted only of separators: skip it
++_inputPtr;
_pendingLF = ch;
_handleLF();
return true;
}
// Found non-separator content: not an empty row.
// Record consumed separators so nextString() replays them.
_pendingEmptyColumns = separatorCount;
return false;
}
}
/**
* Method called to blindly skip a single line of content, without considering
* aspects like quoting or escaping. Used currently simply to skip the first
* line of input document, if instructed to do so.
*/
public boolean skipLine() throws JacksonException {
if (_pendingLF != 0) {
if (_inputReader == null) {
return false;
}
_handleLF();
}
while (_inputPtr < _inputEnd || loadMore()) {
char c = _inputBuffer[_inputPtr++];
if (c == '\r' || c == '\n') {
// important: handle trailing linefeed now, so caller need not bother
_pendingLF = c;
_handleLF();
return true;
}
}
return false;
}
/**
* Method called to parse the next token when we don't have any type
* information, so that all tokens are exposed as basic String
* values.
*
* @return Column value if more found; null to indicate end of line
* of input
*/
public String nextString() throws JacksonException {
_numTypesValid = NR_UNKNOWN;
_currInputQuoted = false; // Reset; set to true below only if opening quote found
// [dataformats-text#368]: Replay separator characters consumed by _trySkipEmptyRow()
// as empty column values
if (_pendingEmptyColumns > 0) {
--_pendingEmptyColumns;
_textBuffer.resetWithString("");
return "";
}
if (_pendingLF > 0) { // either pendingLF, or closed
if (_inputReader != null) { // if closed, we just need to return null
_handleLF();
}
return null; // end of line without new value
}
int i;
if (_trimSpaces) {
i = _skipLeadingSpace();
} else {
i = _nextChar();
// [dataformats-text#643]: Even without TRIM_SPACES, spaces before
// a quoted value are insignificant and should be skipped.
// Consume whitespace across buffer boundaries; if a quote follows,
// discard the spaces and parse as quoted. If not, restore consumed
// spaces into the unquoted output.
if (i <= ' ' && i > 0
&& i != _separatorChar && i != INT_CR && i != INT_LF) {
// Lazily allocate / reuse buffer for consumed whitespace
char[] spaceBuf = _leadingSpaceBuf;
if (spaceBuf == null) {
_leadingSpaceBuf = spaceBuf = new char[16];
}
int spaceCount = 0;
spaceBuf[spaceCount++] = (char) i;
boolean foundQuote = false;
while (true) {
if (_inputPtr >= _inputEnd) {
if (!loadMore()) {
break;
}
}
final char ch = _inputBuffer[_inputPtr];
if (ch == _quoteChar) {
// Found quote: discard leading spaces, proceed as quoted
_inputPtr++;
i = _quoteChar;
foundQuote = true;
break;
}
if (ch > ' ' || ch == _separatorChar
|| ch == '\r' || ch == '\n') {
break;
}
// Consume this whitespace character, tracking it for restoration
_inputPtr++;
if (spaceCount >= spaceBuf.length) {
_leadingSpaceBuf = spaceBuf =
Arrays.copyOf(spaceBuf, spaceBuf.length * 2);
}
spaceBuf[spaceCount++] = ch;
}
if (!foundQuote && spaceCount > 0) {
// Not a quoted value: restore consumed whitespace into unquoted output
_tokenInputTotal = _currInputProcessed + _inputPtr - 1;
_tokenInputRow = _currInputRow;
_tokenInputCol = _inputPtr - _currInputRowStart - 1;
_textBuffer.resetWithCopy(spaceBuf, 0, spaceCount);
return _nextUnquotedString(_textBuffer.getBufferWithoutReset(),
_textBuffer.getCurrentSegmentSize());
}
}
}
// First, need to ensure we know the starting location of token
_tokenInputTotal = _currInputProcessed + _inputPtr - 1;
_tokenInputRow = _currInputRow;
_tokenInputCol = _inputPtr - _currInputRowStart - 1;
if (i < 0) { // EOF at this point signifies empty value
_textBuffer.resetWithString("");
return "";
}
if (i == INT_CR || i == INT_LF) { // end-of-line means end of record; but also need to handle LF later on
_pendingLF = i;
_textBuffer.resetWithString("");
return "";
}
// two modes: quoted, unquoted
_currInputQuoted = i == _quoteChar; // Keep track of quoting
if (_currInputQuoted) { // offline quoted case (longer)
return _nextQuotedString();
}
if (i == _separatorChar) {
_textBuffer.resetWithString("");
return "";
}
char[] outBuf = _textBuffer.emptyAndGetCurrentSegment();
outBuf[0] = (char) i;
int outPtr = 1;
if (i == _escapeChar) {
// Reset the escaped character
outBuf[0] = _unescape();
return _nextUnquotedString(outBuf, outPtr);
}
int ptr = _inputPtr;
if (ptr >= _inputEnd) {
if (!loadMore()) { // ok to have end-of-input but...
return _textBuffer.finishAndReturn(outPtr, _trimSpaces);
}
ptr = _inputPtr;
}
final int end;
{
int max = Math.min(_inputEnd - ptr, outBuf.length - outPtr);
end = ptr + max;
}
// handle unquoted case locally if it can be handled without
// crossing buffer boundary...
char[] inputBuffer = _inputBuffer;
while (ptr < end) {
char c = inputBuffer[ptr++];
if (c <= _maxSpecialChar) {
if (c == _separatorChar) { // end of value, yay!
_inputPtr = ptr;
return _textBuffer.finishAndReturn(outPtr, _trimSpaces);
}
if (c == '\r' || c == '\n') {
_pendingLF = c;
_inputPtr = ptr;
return _textBuffer.finishAndReturn(outPtr, _trimSpaces);
}
if (c == _escapeChar) {
--ptr;
break;
}
}
outBuf[outPtr++] = c;
}
// ok, either input or output across buffer boundary, offline
_inputPtr = ptr;
return _nextUnquotedString(outBuf, outPtr);
}
public JsonToken nextStringOrLiteral() throws JacksonException {
_numTypesValid = NR_UNKNOWN;
// !!! TODO: implement properly
String value = nextString();
if (value == null) {
return null;
}
return JsonToken.VALUE_STRING;
}
public JsonToken nextNumber() throws JacksonException {
_numTypesValid = NR_UNKNOWN;
// !!! TODO: implement properly
String value = nextString();
if (value == null) {
return null;
}
return JsonToken.VALUE_STRING;
}
public JsonToken nextNumberOrString() throws JacksonException {
_numTypesValid = NR_UNKNOWN;
// !!! TODO: implement properly
String value = nextString();
if (value == null) {
return null;
}
return JsonToken.VALUE_STRING;
}
/*
/**********************************************************************
/* Actual parsing, private helper methods
/**********************************************************************
*/
protected String _nextUnquotedString(char[] outBuf, int outPtr) throws JacksonException {
int c;
final char[] inputBuffer = _inputBuffer;
main_loop:
while (true) {
int ptr = _inputPtr;
if (ptr >= _inputEnd) {
if (!loadMore()) { // ok to have end-of-input, are done
_inputPtr = ptr;
break main_loop;
}
ptr = _inputPtr;
}
if (outPtr >= outBuf.length) {
outBuf = _textBuffer.finishCurrentSegment();
outPtr = 0;
}
final int max = Math.min(_inputEnd, (ptr + (outBuf.length - outPtr)));
while (ptr < max) {
c = inputBuffer[ptr++];
if (c <= _maxSpecialChar) {
if (c == _separatorChar) { // end of value, yay!
_inputPtr = ptr;
break main_loop;
}
if (c == '\r' || c == '\n') { // end of line is end of value as well
_inputPtr = ptr;
_pendingLF = c;
break main_loop;
}
if (c == _escapeChar) {
_inputPtr = ptr;
outBuf[outPtr++] = _unescape();
// May have passed input boundary, need to re-set
continue main_loop;
}
}
outBuf[outPtr++] = (char) c;
}
_inputPtr = ptr;
}
return _textBuffer.finishAndReturn(outPtr, _trimSpaces);
}
protected String _nextQuotedString() throws JacksonException {
char[] outBuf = _textBuffer.emptyAndGetCurrentSegment();
int outPtr = 0;
final char[] inputBuffer = _inputBuffer;
boolean checkLF = false; // marker for split CR+LF
main_loop:
while (true) {
int ptr = _inputPtr;
if (ptr >= _inputEnd) {
if (!loadMore()) { // not ok, missing end quote
_owner._reportError("Missing closing quote for value"); // should indicate start position?
}
ptr = _inputPtr;
if (checkLF) {
checkLF = false; // better reset
if (inputBuffer[ptr] == '\n') {
// undo earlier advancement, to keep line number correct
--_currInputRow;
}
}
}
// 11-Feb-2024, tatu: Not quite sure what was supposed to happen here;
// but nothing was done. Leaving for now, remove from 2.18 or later
/*
if (checkLF) { // had a "hanging" CR in parse loop; check now
}
*/
if (outPtr >= outBuf.length) {
outBuf = _textBuffer.finishCurrentSegment();
outPtr = 0;
}
final int max = Math.min(_inputEnd, (ptr + (outBuf.length - outPtr)));
inner_loop:
while (true) {
char c = inputBuffer[ptr++];
if (c <= _maxSpecialChar) {
if (c == _quoteChar) {
_inputPtr = ptr;
break;
}
// Embedded linefeeds are fine
if (c == '\r') {
// bit crappy check but has to do:
if (ptr >= max) {
checkLF = true; // will need to be checked in beginning of next loop
++_currInputRow;
_currInputRowStart = ptr;
} else if (inputBuffer[ptr] != '\n') {
++_currInputRow;
_currInputRowStart = ptr;
}
} else if (c == '\n') {
++_currInputRow;
_currInputRowStart = ptr;
} else if (c == _escapeChar) {
_inputPtr = ptr;
c = _unescape();
outBuf[outPtr++] = c;
// May have passed input boundary, need to re-set
continue main_loop;
}
}
outBuf[outPtr++] = c;
if (ptr >= max) {
_inputPtr = ptr;
continue main_loop;
}
continue inner_loop;
}
// We get here if we hit a quote: check if it's doubled up, or end of value:
if (_inputPtr < _inputEnd || loadMore()) {
if (_inputBuffer[_inputPtr] == _quoteChar) { // doubled up, append
// note: should have enough room, is safe
outBuf[outPtr++] = (char) _quoteChar;
++_inputPtr;
continue main_loop;
}
}
// Not doubled; leave next char as is
break;
}
// note: do NOT trim from within quoted Strings
String result = _textBuffer.finishAndReturn(outPtr, false);
// good, but we also need to locate and skip trailing space, separator
// (note: space outside quotes never included, but must be skipped)
while (_inputPtr < _inputEnd || loadMore()) { // end-of-input is fine
int ch = _inputBuffer[_inputPtr++];
if (ch == _separatorChar) { // common case, separator between columns
break;
}
if (ch <= INT_SPACE) { // extra space, fine as well
if (ch == INT_CR || ch == INT_LF) { // but end-of-line can't be yet skipped
_pendingLF = ch;
break;
}
continue;
}
_owner._reportUnexpectedCsvChar(ch, String.format(
"Expected column separator character (%s) or end-of-line", _getCharDesc(_separatorChar)));
}
return result;
}
protected final void _handleLF() throws JacksonException
{
// already skipped past first part; but may get \r\n so skip the other char too?
if (_pendingLF == INT_CR) {
if (_inputPtr < _inputEnd || loadMore()) {
if (_inputBuffer[_inputPtr] == '\n') {
++_inputPtr;
}
}
}
_pendingLF = 0;
++_currInputRow;
_currInputRowStart = _inputPtr;
}
protected char _unescape() throws JacksonException {
if (_inputPtr >= _inputEnd) {
if (!loadMore()) {
_reportError("Unexpected EOF in escaped character");
}
}
// Some characters are more special than others, so:
char c = _inputBuffer[_inputPtr++];
switch (c) {
case '0':
return '\0';
case 'n':
return '\n';
case 'r':
return '\r';
case 't':
return '\t';
}
// others, return as is...
return c;
}
protected final int _nextChar() throws JacksonException {
if (_inputPtr >= _inputEnd) {
if (!loadMore()) {
return -1;
}
}
return _inputBuffer[_inputPtr++];
}
protected final int _skipLeadingSpace() throws JacksonException {
final int sep = _separatorChar;
while (true) {
if (_inputPtr >= _inputEnd) {
if (!loadMore()) {
return -1;
}
}
char ch = _inputBuffer[_inputPtr++];
if ((ch > ' ') || (ch == sep)) {
return ch;
}
switch (ch) {
case '\r':
case '\n':
return ch;
}
}
}
/*
/**********************************************************************
/* Numeric accessors for CsvParser
/**********************************************************************
*/
/**
* Method used by {@link CsvParser#isExpectedNumberIntToken()} to coerce
* current token into integer number, if it looks like one.
*/
public boolean isExpectedNumberIntToken() throws JacksonException
{
if (looksLikeInt()) {
_parseIntValue();
return true;
}
return false;
}
/**
* @param exact Whether we should try to retain maximum precision or not;
* passed as {@code true} by {@code getNumberValueExact()}, and as
* {@code false} by regular {@code getNumberValue)}.
*/
public Number getNumberValue(boolean exact) throws JacksonException
{
if (_numTypesValid == NR_UNKNOWN) {
_parseNumericValue(exact); // will also check event type
}
// Separate types for int types
if ((_numTypesValid & NR_INT) != 0) {
return Integer.valueOf(_numberInt);
}
if ((_numTypesValid & NR_LONG) != 0) {
return Long.valueOf(_numberLong);
}
if ((_numTypesValid & NR_BIGINT) != 0) {
return _getBigInteger();
}
// And then floating point types. But here optimal type
// needs to be big decimal, to avoid losing any data?
if ((_numTypesValid & NR_BIGDECIMAL) != 0) {
return _getBigDecimal();
}
if ((_numTypesValid & NR_DOUBLE) == 0) { // sanity check
_throwInternal();
}
return Double.valueOf(_numberDouble);
}
public NumberType getNumberType() throws JacksonException {
if (_numTypesValid == NR_UNKNOWN) {
_parseNumericValue(false); // will also check event type
}
if ((_numTypesValid & NR_INT) != 0) {
return NumberType.INT;
}
if ((_numTypesValid & NR_LONG) != 0) {
return NumberType.LONG;
}
if ((_numTypesValid & NR_BIGINT) != 0) {
return NumberType.BIG_INTEGER;
}
// And then floating point types. Here optimal type
// needs to be big decimal, to avoid losing any data?
// However... using BD is slow, so let's allow returning
// double as type if no explicit call has been made to access data as BD?
if ((_numTypesValid & NR_BIGDECIMAL) != 0) {
return NumberType.BIG_DECIMAL;
}
return NumberType.DOUBLE;
}
public int getIntValue() throws JacksonException {
if ((_numTypesValid & NR_INT) == 0) {
if (_numTypesValid == NR_UNKNOWN) { // not parsed at all
_parseNumericValue(false); // will also check event type
}
if ((_numTypesValid & NR_INT) == 0) { // wasn't an int natively?
convertNumberToInt(); // let's make it so, if possible
}
}
return _numberInt;
}
public long getLongValue() throws JacksonException {
if ((_numTypesValid & NR_LONG) == 0) {
if (_numTypesValid == NR_UNKNOWN) {
_parseNumericValue(false);
}
if ((_numTypesValid & NR_LONG) == 0) {
convertNumberToLong();
}
}
return _numberLong;
}
public BigInteger getBigIntegerValue() throws JacksonException {
if ((_numTypesValid & NR_BIGINT) == 0) {
if (_numTypesValid == NR_UNKNOWN) {
_parseNumericValue(true);
}
if ((_numTypesValid & NR_BIGINT) == 0) {
convertNumberToBigInteger();
}
}
return _getBigInteger();
}
public float getFloatValue() throws JacksonException {
double value = getDoubleValue();
// Bounds/range checks would be tricky here, so let's not bother...
return (float) value;
}
public double getDoubleValue() throws JacksonException {
if ((_numTypesValid & NR_DOUBLE) == 0) {
if (_numTypesValid == NR_UNKNOWN) {
_parseNumericValue(false);
}
if ((_numTypesValid & NR_DOUBLE) == 0) {
convertNumberToDouble();
}
}
return _numberDouble;
}
public BigDecimal getDecimalValue() throws JacksonException {
if ((_numTypesValid & NR_BIGDECIMAL) == 0) {
if (_numTypesValid == NR_UNKNOWN) {
_parseNumericValue(true);
}
if ((_numTypesValid & NR_BIGDECIMAL) == 0) {
convertNumberToBigDecimal();
}
}
return _getBigDecimal();
}
/**
* Internal accessor that needs to be used for accessing number value of type
* {@link BigInteger} which -- as of 2.14 -- is typically lazily parsed.
*/
protected BigInteger _getBigInteger() throws JacksonException {
if (_numberBigInt != null) {
return _numberBigInt;
} else if (_numberString == null) {
throw new IllegalStateException("cannot get BigInteger from current parser state");
}
_ioContext.streamReadConstraints().validateIntegerLength(_numberString.length());
_numberBigInt = NumberInput.parseBigInteger(
_numberString, _owner.isEnabled(StreamReadFeature.USE_FAST_BIG_NUMBER_PARSER));
_numberString = null;
return _numberBigInt;
}
/**
* Internal accessor that needs to be used for accessing number value of type
* {@link BigDecimal} which -- as of 2.14 -- is typically lazily parsed.
*/
protected BigDecimal _getBigDecimal() throws JacksonException {
if (_numberBigDecimal != null) {
return _numberBigDecimal;
} else if (_numberString == null) {
throw new IllegalStateException("cannot get BigDecimal from current parser state");
}
_ioContext.streamReadConstraints().validateFPLength(_numberString.length());
_numberBigDecimal = NumberInput.parseBigDecimal(
_numberString, _owner.isEnabled(StreamReadFeature.USE_FAST_BIG_NUMBER_PARSER));
_numberString = null;
return _numberBigDecimal;
}
/*
/**********************************************************************
/* Conversion from textual to numeric representation
/**********************************************************************
*/
/**
* Method that will parse actual numeric value out of a syntactically
* valid number value. Type it will parse into depends on whether
* it is a floating point number, as well as its magnitude: smallest
* legal type (of ones available) is used for efficiency.
*
* @param exactNumber Whether to try to retain the highest precision for
* floating-point values or not
*/
protected void _parseNumericValue(boolean exactNumber)
throws JacksonException
{
if (looksLikeInt()) {
_parseIntValue();
return;
}
/*
if (_hasFloatToken() == JsonToken.VALUE_NUMBER_FLOAT) {
_parseSlowFloatValue(expType);
return;
}
_reportError("Current token ("+_currToken+") not numeric, can not use numeric value accessors");
*/
_parseSlowFloatValue(exactNumber);
}
private boolean looksLikeInt() throws JacksonException {
final char[] ch = _textBuffer.contentsAsArray();
final int len = ch.length;
if (len == 0) {
return false;
}
int i = 0;
char c = ch[0];
if (c == '-' || c == '+') {
if (len == 1) {
return false;
}
++i;
}
for (; i < len; ++i) {
c = ch[i];
if (c > '9' || c < '0') {
return false;
}
}
return true;
}
// @since 2.12
protected void _parseIntValue() throws JacksonException
{
char[] buf = _textBuffer.getTextBuffer();
int offset = _textBuffer.getTextOffset();
char c = buf[offset];
boolean neg;
if (c == '-') {
neg = true;
++offset;
} else {
neg = false;
if (c == '+') {
++offset;
}
}
int len = buf.length - offset;
if (len <= 9) { // definitely fits in int
int i = NumberInput.parseInt(buf, offset, len);
_numberInt = neg ? -i : i;
_numTypesValid = NR_INT;
return;
}
if (len <= 18) { // definitely fits AND is easy to parse using 2 int parse calls
long l = NumberInput.parseLong(buf, offset, len);
if (neg) {
l = -l;
}
// [JACKSON-230] Could still fit in int, need to check
if (len == 10) {
if (neg) {
if (l >= MIN_INT_L) {
_numberInt = (int) l;
_numTypesValid = NR_INT;
return;
}
} else {
if (l <= MAX_INT_L) {
_numberInt = (int) l;
_numTypesValid = NR_INT;
return;
}
}
}
_numberLong = l;
_numTypesValid = NR_LONG;
return;
}
_parseSlowIntValue(buf, offset, len, neg);
}
private final void _parseSlowFloatValue(boolean exactNumber)
throws JacksonException
{
/* Nope: floating point. Here we need to be careful to get
* optimal parsing strategy: choice is between accurate but
* slow (BigDecimal) and lossy but fast (Double). For now
* let's only use BD when explicitly requested -- it can
* still be constructed correctly at any point since we do
* retain textual representation
*/
try {
if (exactNumber) {
_numberBigDecimal = null;
_numberString = _textBuffer.contentsAsString();
_numTypesValid = NR_BIGDECIMAL;
} else {
// Otherwise double has to do
_numberDouble = _textBuffer.contentsAsDouble(_owner.isEnabled(StreamReadFeature.USE_FAST_DOUBLE_PARSER));
_numTypesValid = NR_DOUBLE;
}
} catch (NumberFormatException nex) {
// Can this ever occur? Due to overflow, maybe?
throw _constructReadException(nex, "Malformed numeric value '" + _textBuffer.contentsAsString() + "'");
}
}
private final void _parseSlowIntValue(char[] buf, int offset, int len,
boolean neg)
throws JacksonException
{
String numStr = _textBuffer.contentsAsString();
try {
if (NumberInput.inLongRange(buf, offset, len, neg)) {
// Probably faster to construct a String, call parse, than to use BigInteger
_numberLong = Long.parseLong(numStr);
_numTypesValid = NR_LONG;
} else {
// nope, need the heavy guns... (rare case)
_numberBigInt = null;
_numberString = numStr;
_numTypesValid = NR_BIGINT;
}
} catch (NumberFormatException nex) {
// Can this ever occur? Due to overflow, maybe?
throw _constructReadException(nex, "Malformed numeric value '" + numStr + "'");
}
}
/*
/**********************************************************************
/* Numeric conversions
/**********************************************************************
*/
protected void convertNumberToInt() throws JacksonException {
// First, converting from long ought to be easy
if ((_numTypesValid & NR_LONG) != 0) {
// Let's verify it's lossless conversion by simple roundtrip
int result = (int) _numberLong;
if (result != _numberLong) {
_reportError("Numeric value (" + getText() + ") out of range of int");
}
_numberInt = result;
} else if ((_numTypesValid & NR_BIGINT) != 0) {
final BigInteger bigInteger = _getBigInteger();
if (BI_MIN_INT.compareTo(bigInteger) > 0
|| BI_MAX_INT.compareTo(bigInteger) < 0) {
reportOverflowInt();
}
_numberInt = bigInteger.intValue();
} else if ((_numTypesValid & NR_DOUBLE) != 0) {
// Need to check boundaries
if (_numberDouble < MIN_INT_D || _numberDouble > MAX_INT_D) {
reportOverflowInt();
}
_numberInt = (int) _numberDouble;
} else if ((_numTypesValid & NR_BIGDECIMAL) != 0) {
final BigDecimal bigDecimal = _getBigDecimal();
if (BD_MIN_INT.compareTo(bigDecimal) > 0
|| BD_MAX_INT.compareTo(bigDecimal) < 0) {
reportOverflowInt();
}
_numberInt = bigDecimal.intValue();
} else {
_throwInternal(); // should never get here
}
_numTypesValid |= NR_INT;
}
protected void convertNumberToLong() throws JacksonException {
if ((_numTypesValid & NR_INT) != 0) {
_numberLong = _numberInt;
} else if ((_numTypesValid & NR_BIGINT) != 0) {
final BigInteger bigInteger = _getBigInteger();
if (BI_MIN_LONG.compareTo(bigInteger) > 0
|| BI_MAX_LONG.compareTo(bigInteger) < 0) {
reportOverflowLong();
}
_numberLong = bigInteger.longValue();
} else if ((_numTypesValid & NR_DOUBLE) != 0) {
// Need to check boundaries
if (_numberDouble < MIN_LONG_D || _numberDouble > MAX_LONG_D) {
reportOverflowLong();
}
_numberLong = (long) _numberDouble;
} else if ((_numTypesValid & NR_BIGDECIMAL) != 0) {
final BigDecimal bigDecimal = _getBigDecimal();
if (BD_MIN_LONG.compareTo(bigDecimal) > 0
|| BD_MAX_LONG.compareTo(bigDecimal) < 0) {
reportOverflowLong();
}
_numberLong = bigDecimal.longValue();
} else {
_throwInternal(); // should never get here
}
_numTypesValid |= NR_LONG;
}
protected void convertNumberToBigInteger()
throws JacksonException {
if ((_numTypesValid & NR_BIGDECIMAL) != 0) {
// here it'll just get truncated, no exceptions thrown
final BigDecimal bd = _getBigDecimal();
_ioContext.streamReadConstraints().validateBigIntegerScale(bd.scale());
_numberBigInt = bd.toBigInteger();
} else if ((_numTypesValid & NR_LONG) != 0) {
_numberBigInt = BigInteger.valueOf(_numberLong);
} else if ((_numTypesValid & NR_INT) != 0) {
_numberBigInt = BigInteger.valueOf(_numberInt);
} else if ((_numTypesValid & NR_DOUBLE) != 0) {
_numberBigInt = BigDecimal.valueOf(_numberDouble).toBigInteger();
} else {
_throwInternal(); // should never get here
}
_numTypesValid |= NR_BIGINT;
}
protected void convertNumberToDouble()
throws JacksonException {
// 05-Aug-2008, tatus: Important note: this MUST start with
// more accurate representations, since we don't know which
// value is the original one (others get generated when
// requested)
if ((_numTypesValid & NR_BIGDECIMAL) != 0) {
_numberDouble = _getBigDecimal().doubleValue();
} else if ((_numTypesValid & NR_BIGINT) != 0) {
_numberDouble = _getBigInteger().doubleValue();
} else if ((_numTypesValid & NR_LONG) != 0) {
_numberDouble = _numberLong;
} else if ((_numTypesValid & NR_INT) != 0) {
_numberDouble = _numberInt;
} else {
_throwInternal(); // should never get here
}
_numTypesValid |= NR_DOUBLE;
}
protected void convertNumberToBigDecimal() throws JacksonException {
if ((_numTypesValid & NR_DOUBLE) != 0) {
// Let's actually parse from String representation, to avoid
// rounding errors that non-decimal floating operations could incur
final String text = getText();
_ioContext.streamReadConstraints().validateFPLength(text.length());
_numberBigDecimal = NumberInput.parseBigDecimal(
text, _owner.isEnabled(StreamReadFeature.USE_FAST_BIG_NUMBER_PARSER));
} else if ((_numTypesValid & NR_BIGINT) != 0) {
_numberBigDecimal = new BigDecimal(_getBigInteger());
} else if ((_numTypesValid & NR_LONG) != 0) {
_numberBigDecimal = BigDecimal.valueOf(_numberLong);
} else if ((_numTypesValid & NR_INT) != 0) {
_numberBigDecimal = BigDecimal.valueOf(_numberInt);
} else {
_throwInternal(); // should never get here
}
_numTypesValid |= NR_BIGDECIMAL;
}
/*
/**********************************************************
/* Number handling exceptions
/**********************************************************
*/
protected void reportUnexpectedNumberChar(int ch, String comment)
throws StreamReadException
{
String msg = "Unexpected character (" + _getCharDesc(ch) + ") in numeric value";
if (comment != null) {
msg += ": " + comment;
}
_reportError(msg);
}
protected void reportInvalidNumber(String msg) throws StreamReadException {
_reportError("Invalid numeric value: " + msg);
}
protected void reportOverflowInt() throws StreamReadException {
_reportError("Numeric value (" + getText() + ") out of range of int (" + Integer.MIN_VALUE + " - " + Integer.MAX_VALUE + ")");
}
protected void reportOverflowLong() throws StreamReadException {
_reportError("Numeric value (" + getText() + ") out of range of long (" + Long.MIN_VALUE + " - " + Long.MAX_VALUE + ")");
}
protected final StreamReadException _constructReadException(Throwable t, String msg) {
return new StreamReadException(_owner, msg, t);
}
protected final static String _getCharDesc(int ch) {
char c = (char) ch;
if (Character.isISOControl(c)) {
return "(CTRL-CHAR, code " + ch + ")";
}
if (ch > 255) {
return "'" + c + "' (code " + ch + " / 0x" + Integer.toHexString(ch) + ")";
}
return "'" + c + "' (code " + ch + ")";
}
private void _throwInternal() {
throw new IllegalStateException("Internal error: code path should never get executed");
}
/**
* Method for reporting low-level decoding (parsing) problems
*/
protected final void _reportError(String msg) throws StreamReadException {
throw new StreamReadException(_owner, msg);
}
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/impl/CsvEncoder.java
================================================
package tools.jackson.dataformat.csv.impl;
import java.io.IOException;
import java.io.Writer;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;
import tools.jackson.core.JacksonException;
import tools.jackson.core.exc.JacksonIOException;
import tools.jackson.core.io.CharTypes;
import tools.jackson.core.io.CharacterEscapes;
import tools.jackson.core.io.IOContext;
import tools.jackson.core.io.NumberOutput;
import tools.jackson.dataformat.csv.CsvSchema;
import tools.jackson.dataformat.csv.CsvWriteException;
import tools.jackson.dataformat.csv.CsvWriteFeature;
/**
* Helper class that handles actual low-level construction of
* CSV output, based only on indexes given without worrying about reordering,
* or binding from logical properties.
*/
public class CsvEncoder
{
// Default set of escaped characters (none)
private static final int [] sOutputEscapes = new int[0];
// Upper case hex chars:
protected final static char[] HEX_CHARS = CharTypes.copyHexChars(true);
/**
* As an optimization we try coalescing short writes into
* buffer; but pass longer directly.
*/
protected final static int SHORT_WRITE = 32;
/**
* Default maximum length of a column value that will be inspected
* character-by-character to determine whether quoting is needed
* (when not using {@link CsvWriteFeature#STRICT_CHECK_FOR_QUOTING}).
* Values longer than this are always quoted as a performance optimization.
*
* Configurable via {@link tools.jackson.dataformat.csv.CsvFactoryBuilder#maxQuoteCheckChars(int)}.
*
* @since 3.2
*/
public final static int DEFAULT_MAX_QUOTE_CHECK = 24;
protected final BufferedValue[] NO_BUFFERED = new BufferedValue[0];
private final static char[] TRUE_CHARS = "true".toCharArray();
private final static char[] FALSE_CHARS = "false".toCharArray();
/**
* Currently active set of output escape code definitions (whether
* and how to escape or not).
*/
protected int[] _outputEscapes = sOutputEscapes;
/*
/**********************************************************************
/* Configuration
/**********************************************************************
*/
protected final IOContext _ioContext;
/**
* Underlying {@link Writer} used for output.
*/
protected final Writer _out;
protected final char _cfgColumnSeparator;
protected final int _cfgQuoteCharacter;
protected final int _cfgEscapeCharacter;
protected final char[] _cfgLineSeparator;
protected final char[] _cfgNullValue;
protected final int _cfgLineSeparatorLength;
protected final int _cfgMaxQuoteCheckChars;
/**
* Lowest-valued character that is safe to output without using
* quotes around value, NOT including possible escape character.
*/
protected final int _cfgMinSafeChar;
protected final int _csvFeatures;
/**
* Marker flag used to determine if to do optimal (aka "strict") quoting
* checks or not (looser conservative check)
*/
protected final boolean _cfgOptimalQuoting;
protected final boolean _cfgAllowsComments;
protected final boolean _cfgIncludeMissingTail;
protected final boolean _cfgAlwaysQuoteStrings;
protected final boolean _cfgAlwaysQuoteEmptyStrings;
// @since 2.16
protected final boolean _cfgAlwaysQuoteNumbers;
// @since 3.2
protected final boolean _cfgQuoteLeadingTrailingWhitespace;
protected final boolean _cfgEscapeQuoteCharWithEscapeChar;
protected final boolean _cfgEscapeControlCharWithEscapeChar;
/**
* @since 2.14
*/
protected final boolean _cfgUseFastDoubleWriter;
protected final char _cfgQuoteCharEscapeChar;
protected final char _cfgControlCharEscapeChar;
/*
/**********************************************************************
/* Output state
/**********************************************************************
*/
protected int _columnCount;
/**
* Index of column we expect to write next
*/
protected int _nextColumnToWrite = 0;
/**
* And if output comes in shuffled order we will need to do
* bit of ordering.
*/
protected BufferedValue[] _buffered = NO_BUFFERED;
/**
* Index of the last buffered value
*/
protected int _lastBuffered = -1;
protected boolean _trailingLFRemoved = false;
/*
/**********************************************************************
/* Output buffering, low-level
/**********************************************************************
*/
/**
* Intermediate buffer in which contents are buffered before
* being written using {@link #_out}.
*/
protected char[] _outputBuffer;
/**
* Flag that indicates whether the
* Note: includes possible BOMs, if those were part of the input.
*/
protected int _inputProcessed;
/*
/**********************************************************************
/* Data gathered
/**********************************************************************
*/
protected boolean _bigEndian = true;
protected int _bytesPerChar = 0; // 0 means "dunno yet"
/*
/**********************************************************************
/* Life-cycle
/**********************************************************************
*/
public CsvParserBootstrapper(IOContext ctxt, InputStream in)
{
_context = ctxt;
_in = in;
_inputBuffer = ctxt.allocReadIOBuffer();
_inputEnd = _inputPtr = 0;
_inputProcessed = 0;
}
public CsvParserBootstrapper(IOContext ctxt,
byte[] inputBuffer, int inputStart, int inputLen)
{
_context = ctxt;
_in = null;
_inputBuffer = inputBuffer;
_inputPtr = inputStart;
_inputEnd = (inputStart + inputLen);
// Need to offset this for correct location info
_inputProcessed = -inputStart;
}
/*
/**********************************************************************
/* Public API
/**********************************************************************
*/
public CsvParser constructParser(ObjectReadContext readCtxt,
int parserFeatures, int csvFeatures,
CsvSchema schema)
throws JacksonException
{
boolean foundEncoding = false;
// First things first: BOM handling
if (ensureLoaded(4)) {
int quad = (_inputBuffer[_inputPtr] << 24)
| ((_inputBuffer[_inputPtr+1] & 0xFF) << 16)
| ((_inputBuffer[_inputPtr+2] & 0xFF) << 8)
| (_inputBuffer[_inputPtr+3] & 0xFF);
if (handleBOM(quad)) {
foundEncoding = true;
} else {
/* If no BOM, let's see if it's a fixed-width multi-byte
* (since we can be fairly certain no CSV document should
* start with null bytes otherwise...)
*/
// UTF-32?
if (checkUTF32(quad)) {
foundEncoding = true;
} else if (checkUTF16(quad >>> 16)) {
foundEncoding = true;
}
}
} else if (ensureLoaded(2)) {
int i16 = ((_inputBuffer[_inputPtr] & 0xFF) << 8)
| (_inputBuffer[_inputPtr+1] & 0xFF);
if (checkUTF16(i16)) {
foundEncoding = true;
}
}
JsonEncoding enc;
/* Not found yet? As per specs, this means it must be UTF-8. */
if (!foundEncoding || _bytesPerChar == 1) {
enc = JsonEncoding.UTF8;
} else if (_bytesPerChar == 2) {
enc = _bigEndian ? JsonEncoding.UTF16_BE : JsonEncoding.UTF16_LE;
} else if (_bytesPerChar == 4) {
enc = _bigEndian ? JsonEncoding.UTF32_BE : JsonEncoding.UTF32_LE;
} else {
throw new RuntimeException("Internal error"); // should never get here
}
_context.setEncoding(enc);
final boolean autoClose = _context.isResourceManaged()
|| StreamReadFeature.AUTO_CLOSE_SOURCE.enabledIn(parserFeatures);
return new CsvParser(readCtxt, _context,
parserFeatures, csvFeatures, schema,
_createReader(enc, autoClose));
}
@SuppressWarnings("resource")
private Reader _createReader(JsonEncoding enc, boolean autoClose)
throws JacksonException
{
switch (enc) {
case UTF32_BE:
case UTF32_LE:
return new UTF32Reader(_context, _in, autoClose,
_inputBuffer, _inputPtr, _inputEnd, enc.isBigEndian());
case UTF16_BE:
case UTF16_LE:
{
// First: do we have a Stream? If not, need to create one:
InputStream in = _in;
if (in == null) {
in = new ByteArrayInputStream(_inputBuffer, _inputPtr, _inputEnd);
} else {
// Also, if we have any read but unused input (usually true),
// need to merge that input in:
if (_inputPtr < _inputEnd) {
in = new MergedStream(_context, in, _inputBuffer, _inputPtr, _inputEnd);
}
}
try {
return new InputStreamReader(in, enc.getJavaName());
} catch (IOException e) {
throw _wrapIOFailure(e);
}
}
case UTF8:
// Important: do not pass context, if we got byte[], nothing to release
return new UTF8Reader((_in == null) ? null : _context, _in, autoClose,
_inputBuffer, _inputPtr, _inputEnd - _inputPtr);
default:
throw new RuntimeException();
}
}
/*
/**********************************************************************
/* Internal methods, parsing
/**********************************************************************
*/
/**
* @return True if a BOM was successfully found, and encoding
* thereby recognized.
*/
private boolean handleBOM(int quad) throws JacksonException
{
// Handling of (usually) optional BOM (required for
// multi-byte formats); first 32-bit charsets:
switch (quad) {
case 0x0000FEFF:
_bigEndian = true;
_inputPtr += 4;
_bytesPerChar = 4;
return true;
case 0xFFFE0000: // UCS-4, LE?
_inputPtr += 4;
_bytesPerChar = 4;
_bigEndian = false;
return true;
case 0x0000FFFE: // UCS-4, in-order...
reportWeirdUCS4("2143"); // throws exception
case 0xFEFF0000: // UCS-4, in-order...
reportWeirdUCS4("3412"); // throws exception
}
// Ok, if not, how about 16-bit encoding BOMs?
int msw = quad >>> 16;
if (msw == 0xFEFF) { // UTF-16, BE
_inputPtr += 2;
_bytesPerChar = 2;
_bigEndian = true;
return true;
}
if (msw == 0xFFFE) { // UTF-16, LE
_inputPtr += 2;
_bytesPerChar = 2;
_bigEndian = false;
return true;
}
// And if not, then UTF-8 BOM?
if ((quad >>> 8) == 0xEFBBBF) { // UTF-8
_inputPtr += 3;
_bytesPerChar = 1;
_bigEndian = true; // doesn't really matter
return true;
}
return false;
}
private boolean checkUTF32(int quad) throws JacksonException
{
/* Handling of (usually) optional BOM (required for
* multi-byte formats); first 32-bit charsets:
*/
if ((quad >> 8) == 0) { // 0x000000?? -> UTF32-BE
_bigEndian = true;
} else if ((quad & 0x00FFFFFF) == 0) { // 0x??000000 -> UTF32-LE
_bigEndian = false;
} else if ((quad & ~0x00FF0000) == 0) { // 0x00??0000 -> UTF32-in-order
reportWeirdUCS4("3412");
} else if ((quad & ~0x0000FF00) == 0) { // 0x0000??00 -> UTF32-in-order
reportWeirdUCS4("2143");
} else {
// Can not be valid UTF-32 encoded JSON...
return false;
}
// Not BOM (just regular content), nothing to skip past:
//_inputPtr += 4;
_bytesPerChar = 4;
return true;
}
private boolean checkUTF16(int i16)
{
if ((i16 & 0xFF00) == 0) { // UTF-16BE
_bigEndian = true;
} else if ((i16 & 0x00FF) == 0) { // UTF-16LE
_bigEndian = false;
} else { // nope, not UTF-16
return false;
}
// Not BOM (just regular content), nothing to skip past:
//_inputPtr += 2;
_bytesPerChar = 2;
return true;
}
/*
/**********************************************************************
/* Internal methods, problem reporting
/**********************************************************************
*/
private void reportWeirdUCS4(String type) throws JacksonException {
throw _createIOFailure("Unsupported UCS-4 endianness ("+type+") detected");
}
/*
/**********************************************************************
/* Internal methods, raw input access
/**********************************************************************
*/
protected boolean ensureLoaded(int minimum) throws JacksonException
{
/* Let's assume here buffer has enough room -- this will always
* be true for the limited used this method gets
*/
int gotten = (_inputEnd - _inputPtr);
while (gotten < minimum) {
int count;
if (_in == null) { // block source
count = -1;
} else {
try {
count = _in.read(_inputBuffer, _inputEnd, _inputBuffer.length - _inputEnd);
} catch (IOException e) {
throw _wrapIOFailure(e);
}
}
if (count < 1) {
return false;
}
_inputEnd += count;
gotten += count;
}
return true;
}
/*
/**********************************************************************
/* Internal methods, exception handling
/**********************************************************************
*/
private static JacksonException _createIOFailure(String msg) throws JacksonException {
// 12-Jan-2021, tatu: Couple of alternatives, but since this is before
// actual parser created, seems best to simply fake this was "true"
// IOException
return _wrapIOFailure(new IOException(msg));
}
private static JacksonException _wrapIOFailure(IOException e) throws JacksonException {
return JacksonIOException.construct(e);
}
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/impl/UTF8Reader.java
================================================
package tools.jackson.dataformat.csv.impl;
import java.io.*;
import java.util.Objects;
import tools.jackson.core.io.IOContext;
/**
* Optimized Reader that reads UTF-8 encoded content from an input stream.
* In addition to doing (hopefully) optimal conversion, it can also take
* array of "pre-read" (leftover) bytes; this is necessary when preliminary
* stream/reader is trying to figure out underlying character encoding.
*/
public final class UTF8Reader
extends Reader
{
/**
* IO context to use for returning input buffer, iff
* buffer is to be recycled when input ends.
*/
private final IOContext _ioContext;
private InputStream _inputSource;
private final boolean _autoClose;
private byte[] _inputBuffer;
/**
* Flag set to indicate {@code inputBuffer} is read-only, and its
* content should not be modified. This is the case when caller
* has passed in a buffer of contents already read, instead of Jackson
* allocating read buffer.
*
* @since 2.19
*/
private final boolean _inputBufferReadOnly;
/**
* Pointer to the next available byte (if any), iff less than
*
* Note: original implementation based on writer from Jackson core package;
* modified slightly, copied to reduce dependency to impl details.
*/
public final class UTF8Writer
extends Writer
{
final private static int SURR1_FIRST = 0xD800;
final private static int SURR1_LAST = 0xDBFF;
final private static int SURR2_FIRST = 0xDC00;
final private static int SURR2_LAST = 0xDFFF;
final private IOContext _context;
private OutputStream _out;
private byte[] _outBuffer;
final private int _outBufferEnd;
private int _outPtr;
/**
* When outputting chars from BMP, surrogate pairs need to be coalesced.
* To do this, both pairs must be known first; and since it is possible
* pairs may be split, we need temporary storage for the first half
*/
private int _surrogate = 0;
public UTF8Writer(IOContext ctxt, OutputStream out)
{
_context = ctxt;
_out = out;
_outBuffer = ctxt.allocWriteEncodingBuffer();
// Max. expansion for a single char (in unmodified UTF-8) is 4 bytes (or 3 depending
// on how you view it -- 4 when recombining surrogate pairs)
_outBufferEnd = _outBuffer.length - 4;
_outPtr = 0;
}
@Override
public Writer append(char c) throws IOException
{
write(c);
return this;
}
@Override
public void close() throws IOException
{
if (_out != null) {
if (_outPtr > 0) {
_out.write(_outBuffer, 0, _outPtr);
_outPtr = 0;
}
OutputStream out = _out;
_out = null;
byte[] buf = _outBuffer;
if (buf != null) {
_outBuffer = null;
_context.releaseWriteEncodingBuffer(buf);
}
out.close();
/* Let's 'flush' orphan surrogate, no matter what; but only
* after cleanly closing everything else.
*/
int code = _surrogate;
_surrogate = 0;
if (code > 0) {
throwIllegal(code);
}
}
}
@Override
public void flush() throws IOException
{
if (_out != null) {
if (_outPtr > 0) {
_out.write(_outBuffer, 0, _outPtr);
_outPtr = 0;
}
_out.flush();
}
}
@Override
public void write(char[] cbuf) throws IOException {
write(cbuf, 0, cbuf.length);
}
@Override
public void write(char[] cbuf, int off, int len) throws IOException
{
if (len < 2) {
if (len == 1) {
write(cbuf[off]);
}
return;
}
// First: do we have a leftover surrogate to deal with?
if (_surrogate > 0) {
char second = cbuf[off++];
--len;
write(convertSurrogate(second));
// will have at least one more char
}
int outPtr = _outPtr;
byte[] outBuf = _outBuffer;
int outBufLast = _outBufferEnd; // has 4 'spare' bytes
// All right; can just loop it nice and easy now:
len += off; // len will now be the end of input buffer
output_loop:
for (; off < len; ) {
/* First, let's ensure we can output at least 4 bytes
* (longest UTF-8 encoded codepoint):
*/
if (outPtr >= outBufLast) {
_out.write(outBuf, 0, outPtr);
outPtr = 0;
}
int c = cbuf[off++];
// And then see if we have an ASCII char:
if (c < 0x80) { // If so, can do a tight inner loop:
outBuf[outPtr++] = (byte)c;
// Let's calc how many ascii chars we can copy at most:
int maxInCount = (len - off);
int maxOutCount = (outBufLast - outPtr);
if (maxInCount > maxOutCount) {
maxInCount = maxOutCount;
}
maxInCount += off;
ascii_loop:
while (true) {
if (off >= maxInCount) { // done with max. ascii seq
continue output_loop;
}
c = cbuf[off++];
if (c >= 0x80) {
break ascii_loop;
}
outBuf[outPtr++] = (byte) c;
}
}
// Nope, multi-byte:
if (c < 0x800) { // 2-byte
outBuf[outPtr++] = (byte) (0xc0 | (c >> 6));
outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
} else { // 3 or 4 bytes
// Surrogates?
if (c < SURR1_FIRST || c > SURR2_LAST) {
outBuf[outPtr++] = (byte) (0xe0 | (c >> 12));
outBuf[outPtr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
continue;
}
// Yup, a surrogate:
if (c > SURR1_LAST) { // must be from first range
_outPtr = outPtr;
throwIllegal(c);
}
_surrogate = c;
// and if so, followed by another from next range
if (off >= len) { // unless we hit the end?
break;
}
c = convertSurrogate(cbuf[off++]);
if (c > 0x10FFFF) { // illegal in JSON as well as in XML
_outPtr = outPtr;
throwIllegal(c);
}
outBuf[outPtr++] = (byte) (0xf0 | (c >> 18));
outBuf[outPtr++] = (byte) (0x80 | ((c >> 12) & 0x3f));
outBuf[outPtr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
}
}
_outPtr = outPtr;
}
@Override
public void write(int c) throws IOException
{
// First; do we have a left over surrogate?
if (_surrogate > 0) {
c = convertSurrogate(c);
// If not, do we start with a surrogate?
} else if (c >= SURR1_FIRST && c <= SURR2_LAST) {
// Illegal to get second part without first:
if (c > SURR1_LAST) {
throwIllegal(c);
}
// First part just needs to be held for now
_surrogate = c;
return;
}
if (_outPtr >= _outBufferEnd) { // let's require enough room, first
_out.write(_outBuffer, 0, _outPtr);
_outPtr = 0;
}
if (c < 0x80) { // ascii
_outBuffer[_outPtr++] = (byte) c;
} else {
int ptr = _outPtr;
if (c < 0x800) { // 2-byte
_outBuffer[ptr++] = (byte) (0xc0 | (c >> 6));
_outBuffer[ptr++] = (byte) (0x80 | (c & 0x3f));
} else if (c <= 0xFFFF) { // 3 bytes
_outBuffer[ptr++] = (byte) (0xe0 | (c >> 12));
_outBuffer[ptr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
_outBuffer[ptr++] = (byte) (0x80 | (c & 0x3f));
} else { // 4 bytes
if (c > 0x10FFFF) { // illegal
throwIllegal(c);
}
_outBuffer[ptr++] = (byte) (0xf0 | (c >> 18));
_outBuffer[ptr++] = (byte) (0x80 | ((c >> 12) & 0x3f));
_outBuffer[ptr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
_outBuffer[ptr++] = (byte) (0x80 | (c & 0x3f));
}
_outPtr = ptr;
}
}
@Override
public void write(String str) throws IOException {
write(str, 0, str.length());
}
@Override
public void write(String str, int off, int len) throws IOException
{
if (len < 2) {
if (len == 1) {
write(str.charAt(off));
}
return;
}
// First: do we have a leftover surrogate to deal with?
if (_surrogate > 0) {
char second = str.charAt(off++);
--len;
write(convertSurrogate(second));
// will have at least one more char (case of 1 char was checked earlier on)
}
int outPtr = _outPtr;
byte[] outBuf = _outBuffer;
int outBufLast = _outBufferEnd; // has 4 'spare' bytes
// All right; can just loop it nice and easy now:
len += off; // len will now be the end of input buffer
output_loop:
for (; off < len; ) {
/* First, let's ensure we can output at least 4 bytes
* (longest UTF-8 encoded codepoint):
*/
if (outPtr >= outBufLast) {
_out.write(outBuf, 0, outPtr);
outPtr = 0;
}
int c = str.charAt(off++);
// And then see if we have an Ascii char:
if (c < 0x80) { // If so, can do a tight inner loop:
outBuf[outPtr++] = (byte)c;
// Let's calc how many ascii chars we can copy at most:
int maxInCount = (len - off);
int maxOutCount = (outBufLast - outPtr);
if (maxInCount > maxOutCount) {
maxInCount = maxOutCount;
}
maxInCount += off;
ascii_loop:
while (true) {
if (off >= maxInCount) { // done with max. ascii seq
continue output_loop;
}
c = str.charAt(off++);
if (c >= 0x80) {
break ascii_loop;
}
outBuf[outPtr++] = (byte) c;
}
}
// Nope, multi-byte:
if (c < 0x800) { // 2-byte
outBuf[outPtr++] = (byte) (0xc0 | (c >> 6));
outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
} else { // 3 or 4 bytes
// Surrogates?
if (c < SURR1_FIRST || c > SURR2_LAST) {
outBuf[outPtr++] = (byte) (0xe0 | (c >> 12));
outBuf[outPtr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
continue;
}
// Yup, a surrogate:
if (c > SURR1_LAST) { // must be from first range
_outPtr = outPtr;
throwIllegal(c);
}
_surrogate = c;
// and if so, followed by another from next range
if (off >= len) { // unless we hit the end?
break;
}
c = convertSurrogate(str.charAt(off++));
if (c > 0x10FFFF) { // illegal, as per RFC 4627
_outPtr = outPtr;
throwIllegal(c);
}
outBuf[outPtr++] = (byte) (0xf0 | (c >> 18));
outBuf[outPtr++] = (byte) (0x80 | ((c >> 12) & 0x3f));
outBuf[outPtr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
}
}
_outPtr = outPtr;
}
/*
/**********************************************************
/* Internal methods
/**********************************************************
*/
/**
* Method called to calculate UTF code point, from a surrogate pair.
*/
private int convertSurrogate(int secondPart) throws IOException
{
int firstPart = _surrogate;
_surrogate = 0;
// Ok, then, is the second part valid?
if (secondPart < SURR2_FIRST || secondPart > SURR2_LAST) {
throw new IOException("Broken surrogate pair: first char 0x"+Integer.toHexString(firstPart)+", second 0x"+Integer.toHexString(secondPart)+"; illegal combination");
}
return 0x10000 + ((firstPart - SURR1_FIRST) << 10) + (secondPart - SURR2_FIRST);
}
private void throwIllegal(int code) throws IOException
{
if (code > 0x10FFFF) { // over max?
throw new IOException("Illegal character point (0x"+Integer.toHexString(code)+") to output; max is 0x10FFFF as per RFC 4627");
}
if (code >= SURR1_FIRST) {
if (code <= SURR1_LAST) { // Unmatched first part (closing without second part?)
throw new IOException("Unmatched first part of surrogate pair (0x"+Integer.toHexString(code)+")");
}
throw new IOException("Unmatched second part of surrogate pair (0x"+Integer.toHexString(code)+")");
}
// should we ever get this?
throw new IOException("Illegal character point (0x"+Integer.toHexString(code)+") to output");
}
}
================================================
FILE: csv/src/main/resources/META-INF/LICENSE
================================================
This copy of Jackson JSON processor CSV module is licensed under the
Apache (Software) License, version 2.0 ("the License").
See the License for details about distribution rights, and the
specific rights regarding derivative works.
You may obtain a copy of the License at:
http://www.apache.org/licenses/LICENSE-2.0
================================================
FILE: csv/src/main/resources/META-INF/NOTICE
================================================
# Jackson JSON processor
Jackson is a high-performance, Free/Open Source JSON processing library.
It was originally written by Tatu Saloranta (tatu.saloranta@iki.fi), and has
been in development since 2007.
It is currently developed by a community of developers.
## Copyright
Copyright 2007-, Tatu Saloranta (tatu.saloranta@iki.fi)
## Licensing
Jackson components are licensed under Apache (Software) License, version 2.0,
as per accompanying LICENSE file.
## Credits
A list of contributors may be found from CREDITS file, which is included
in some artifacts (usually source distributions); but is always available
from the source code management (SCM) system project uses.
================================================
FILE: csv/src/main/resources/META-INF/services/tools.jackson.core.TokenStreamFactory
================================================
tools.jackson.dataformat.csv.CsvFactory
================================================
FILE: csv/src/main/resources/META-INF/services/tools.jackson.databind.ObjectMapper
================================================
tools.jackson.dataformat.csv.CsvMapper
================================================
FILE: csv/src/test/java/module-info.java
================================================
// CSV unit test Module descriptor
module tools.jackson.dataformat.csv
{
// Since we are not split from Main artifact, will not
// need to depend on Main artifact -- but need its dependencies
requires tools.jackson.core;
requires tools.jackson.databind;
// Additional test lib/framework dependencies
requires org.assertj.core;
requires org.junit.jupiter.api;
requires org.junit.jupiter.params;
// Further, need to open up some packages for JUnit et al
opens tools.jackson.dataformat.csv;
opens tools.jackson.dataformat.csv.deser;
opens tools.jackson.dataformat.csv.filter;
opens tools.jackson.dataformat.csv.fuzz;
opens tools.jackson.dataformat.csv.limits;
opens tools.jackson.dataformat.csv.schema;
opens tools.jackson.dataformat.csv.ser;
opens tools.jackson.dataformat.csv.ser.dos;
opens tools.jackson.dataformat.csv.testutil;
opens tools.jackson.dataformat.csv.testutil.failure;
opens tools.jackson.dataformat.csv.tofix;
}
================================================
FILE: csv/src/test/java/perf/BogusOutputStream.java
================================================
package perf;
import java.io.IOException;
import java.io.OutputStream;
public class BogusOutputStream extends OutputStream
{
protected int _bytes;
@Override
public void write(byte[] buf) { write(buf, 0, buf.length); }
@Override
public void write(byte[] buf, int offset, int len) {
_bytes += len;
}
@Override
public void write(int b) throws IOException {
_bytes++;
}
public int length() { return _bytes; }
}
================================================
FILE: csv/src/test/java/perf/F5500Entry.java
================================================
package perf;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* POJO representing data from form F-5500
*/
public class F5500Entry
{
// 1 - 10
@JsonProperty("ACK_ID") public String ackId;
@JsonProperty("SF_PLAN_YEAR_BEGIN_DATE") public String sfPlanYearBeginDate;
@JsonProperty("SF_TAX_PRD") public String sfTaxPrd;
@JsonProperty("SF_PLAN_ENTITY_CD") public String sfPlanEntityCD;
@JsonProperty("SF_INITIAL_FILING_IND") public String sfInitialFilingInd;
@JsonProperty("SF_AMENDED_IND") public String sfAmendedInd;
@JsonProperty("SF_FINAL_FILING_IND") public String sfFinalFilingInd;
@JsonProperty("SF_SHORT_PLAN_YR_IND") public String sfShortPlanYearInd;
@JsonProperty("SF_5558_APPLICATION_FILED_IND") public String sf5558ApplicationFiledInd;
@JsonProperty("SF_EXT_AUTOMATIC_IND") public String sfExtAutomaticInd;
// 11 - 20
@JsonProperty("SF_DFVC_PROGRAM_IND") public String sfDFVCProgramInd;
@JsonProperty("SF_EXT_SPECIAL_IND") public String sfExtSpecialInd;
@JsonProperty("SF_EXT_SPECIAL_TEXT") public String sfExtSpecialText;
@JsonProperty("SF_PLAN_NAME") public String sfPlanName;
@JsonProperty("SF_PLAN_NUM") public long sfPlanNumber;
@JsonProperty("SF_PLAN_EFF_DATE") public String sfPlanEffectiveDate;
@JsonProperty("SF_SPONSOR_NAME") public String sfSponsorName;
@JsonProperty("SF_SPONSOR_DFE_DBA_NAME") public String sfSponsorDFEDBAName;
@JsonProperty("SF_SPONS_US_ADDRESS1") public String sfSponsorUSAddress1;
@JsonProperty("SF_SPONS_US_ADDRESS2") public String sfSponsorUSAddress2;
// 21 - 30
@JsonProperty("SF_SPONS_US_CITY") public String sfSponsorUSCity;
@JsonProperty("SF_SPONS_US_STATE") public String sfSponsorUSState;
@JsonProperty("SF_SPONS_US_ZIP") public String sfSponsorUSZip;
@JsonProperty("SF_SPONS_FOREIGN_ADDRESS1") public String sfSponsorForeignAddress1;
@JsonProperty("SF_SPONS_FOREIGN_ADDRESS2") public String sfSponsorForeignAddress2;
@JsonProperty("SF_SPONS_FOREIGN_CITY") public String sfSponsorForeignCity;
@JsonProperty("SF_SPONS_FOREIGN_PROV_STATE") public String sfSponsorForeignProvinceOrState;
@JsonProperty("SF_SPONS_FOREIGN_CNTRY") public String sfSponsorForeignCountry;
@JsonProperty("SF_SPONS_FOREIGN_POSTAL_CD") public String sfSponsorForeignPostalCD;
@JsonProperty("SF_SPONS_EIN") public String sfSponsorEIN;
// 31 - 40
@JsonProperty("SF_SPONS_PHONE_NUM") public String sfSponsorPhoneNumber;
@JsonProperty("SF_BUSINESS_CODE") public String sfBusinessCode;
@JsonProperty("SF_ADMIN_NAME") public String sfAdminName;
@JsonProperty("SF_ADMIN_CARE_OF_NAME") public String sfAdminCareOfName;
@JsonProperty("SF_ADMIN_US_ADDRESS1") public String sfAdminUSAddress1;
@JsonProperty("SF_ADMIN_US_ADDRESS2") public String sfAdminUSAddress2;
@JsonProperty("SF_ADMIN_US_CITY") public String sfAdminUSCity;
@JsonProperty("SF_ADMIN_US_STATE") public String sfAdminUSState;
@JsonProperty("SF_ADMIN_US_ZIP") public String sfAdminUSZip;
@JsonProperty("SF_ADMIN_FOREIGN_ADDRESS1") public String sfAdminForeignAddress1;
// 41-50
@JsonProperty("SF_ADMIN_FOREIGN_ADDRESS2") public String sfAdminForeignAddress2;
@JsonProperty("SF_ADMIN_FOREIGN_CITY") public String sfAdminForeignCity;
@JsonProperty("SF_ADMIN_FOREIGN_PROV_STATE") public String sfAdminForeignProvinceState;
@JsonProperty("SF_ADMIN_FOREIGN_CNTRY") public String sfAdminForeignCountry;
@JsonProperty("SF_ADMIN_FOREIGN_POSTAL_CD") public String sfAdminForeignPostalCD;
@JsonProperty("SF_ADMIN_EIN") public String sfAdminEin;
@JsonProperty("SF_ADMIN_PHONE_NUM") public String sfAdminPhoneNumber;
@JsonProperty("SF_LAST_RPT_SPONS_NAME") public String sfLastRptSponsorName;
@JsonProperty("SF_LAST_RPT_SPONS_EIN") public String sfLastRptSponsorEIN;
@JsonProperty("SF_LAST_RPT_PLAN_NUM") public String sfLastRptPlanNumber;
// 51-60
@JsonProperty("SF_TOT_PARTCP_BOY_CNT") public int sfTotalParcpBoyCount;
@JsonProperty("SF_TOT_ACT_RTD_SEP_BENEF_CNT") public int sfTotalAccountRtdSepBenefCount;
@JsonProperty("SF_PARTCP_ACCOUNT_BAL_CNT") public int sfPartcpAccountBalanceCount;
@JsonProperty("SF_ELIGIBLE_ASSETS_IND") public String sfEligibleAssetsInd;
@JsonProperty("SF_IQPA_WAIVER_IND") public String sfIQPAWaiverInd;
@JsonProperty("SF_TOT_ASSETS_BOY_AMT") public int sfTotalAssetsBoyAmount;
@JsonProperty("SF_TOT_LIABILITIES_BOY_AMT") public int sfTotalLiabilitiesBoyAmount;
@JsonProperty("SF_NET_ASSETS_BOY_AMT") public int sfNetAssetsBoyAmt;
@JsonProperty("SF_TOT_ASSETS_EOY_AMT") public int sfTotAssetsEoyAmt;
@JsonProperty("SF_TOT_LIABILITIES_EOY_AMT") public int sfTotalLiabilitiesEOYAmount;
// 61-70
@JsonProperty("SF_NET_ASSETS_EOY_AMT") public int sfNetAssetsEoyAmount;
@JsonProperty("SF_EMPLR_CONTRIB_INCOME_AMT") public int sfEmployerContribIncomeAmount;
@JsonProperty("SF_PARTICIP_CONTRIB_INCOME_AMT") public int sfParticipContribIncomeAmount;
@JsonProperty("SF_OTH_CONTRIB_RCVD_AMT") public int sfOtherContribReceivedAmount;
@JsonProperty("SF_OTHER_INCOME_AMT") public int sfOtherIncomeAmount;
@JsonProperty("SF_TOT_INCOME_AMT") public int sfTotalIncomeAmount;
@JsonProperty("SF_TOT_DISTRIB_BNFT_AMT") public int sftotalDistribuBenefitAmount;
@JsonProperty("SF_CORRECTIVE_DEEMED_DISTR_AMT") public int sfCorrectiveDeemedDistrAmount;
@JsonProperty("SF_ADMIN_SRVC_PROVIDERS_AMT") public int sfAdminSrvcProvidersAmount;
@JsonProperty("SF_OTH_EXPENSES_AMT") public int sfOtherExpensesAmount;
// 71-80
@JsonProperty("SF_TOT_EXPENSES_AMT") public int sfTotalExpensesAmount;
@JsonProperty("SF_NET_INCOME_AMT") public int sfNetIncomeAmount;
@JsonProperty("SF_TOT_PLAN_TRANSFERS_AMT") public int sfTotalPlanTransfersAmount;
@JsonProperty("SF_TYPE_PENSION_BNFT_CODE") public String sfTypePensionBenefitCode;
@JsonProperty("SF_TYPE_WELFARE_BNFT_CODE") public String sfTypeWelfareBenefitCode;
@JsonProperty("SF_FAIL_TRANSMIT_CONTRIB_IND") public String sfFailTransmitContribInd;
@JsonProperty("SF_FAIL_TRANSMIT_CONTRIB_AMT") public int sfFailTransmitContribAmount;
@JsonProperty("SF_PARTY_IN_INT_NOT_RPTD_IND") public String sfPartyInIntNotRptdInd;
@JsonProperty("SF_PARTY_IN_INT_NOT_RPTD_AMT") public int sfPartyInIntNotRptdAmount;
@JsonProperty("SF_PLAN_INS_FDLTY_BOND_IND") public String sfPanInsFidelityBondInd;
// 81-90
@JsonProperty("SF_PLAN_INS_FDLTY_BOND_AMT") public long sfPlanInsFidelityBondAmount;
@JsonProperty("SF_LOSS_DISCV_DUR_YEAR_IND") public String sfLossDiscvDuringYearInd;
@JsonProperty("SF_LOSS_DISCV_DUR_YEAR_AMT") public int sfLossDiscvDuringYearAmount;
@JsonProperty("SF_BROKER_FEES_PAID_IND") public String sfBrokerFeesPaidInd;
@JsonProperty("SF_BROKER_FEES_PAID_AMT") public int sfBrokerFeesPaidAmount;
@JsonProperty("SF_FAIL_PROVIDE_BENEF_DUE_IND") public String sfFailProvideBenefitDueInd;
@JsonProperty("SF_FAIL_PROVIDE_BENEF_DUE_AMT") public int sfFailProvideBenefitDueAmount;
@JsonProperty("SF_PARTCP_LOANS_IND") public String sfPartcpLoansInd;
@JsonProperty("SF_PARTCP_LOANS_EOY_AMT") public int sfPartcpLoansEOYAmount;
@JsonProperty("SF_PLAN_BLACKOUT_PERIOD_IND") public String sfPlanBlackoutPeriodInd;
// 91-100
@JsonProperty("SF_COMPLY_BLACKOUT_NOTICE_IND") public String sfComplyBlackoutNoticeInd;
@JsonProperty("SF_DB_PLAN_FUNDING_REQD_IND") public String sfDBPlanFundingRequiredInd;
@JsonProperty("SF_DC_PLAN_FUNDING_REQD_IND") public String sfDCPlanFundingRequiredInd;
@JsonProperty("SF_RULING_LETTER_GRANT_DATE") public String sfRulingLetterGrantDate;
@JsonProperty("SF_SEC_412_REQ_CONTRIB_AMT") public int sfSec412RequiredContribAmount;
@JsonProperty("SF_EMPLR_CONTRIB_PAID_AMT") public int sfEmployerContribPaidAmount;
@JsonProperty("SF_FUNDING_DEFICIENCY_AMT") public int sfFundingDeficiencyAmount;
@JsonProperty("SF_FUNDING_DEADLINE_IND") public String sfFundingDeadlineInd;
@JsonProperty("SF_RES_TERM_PLAN_ADPT_IND") public String sfResTermPlanAdptInd;
@JsonProperty("SF_RES_TERM_PLAN_ADPT_AMT") public int sfResTermPlanAdptAmount;
// 100-109
@JsonProperty("SF_ALL_PLAN_AST_DISTRIB_IND") public String sfAllPlanAstDistribInd;
@JsonProperty("SF_ADMIN_SIGNED_DATE") public String sfAdminSignedDate;
@JsonProperty("SF_ADMIN_SIGNED_NAME") public String sfAdminSignedName;
@JsonProperty("SF_SPONS_SIGNED_DATE") public String sfSponsorSignedDate;
@JsonProperty("SF_SPONS_SIGNED_NAME") public String sfSponsorSignedName;
@JsonProperty("FILING_STATUS") public String filingStatus;
@JsonProperty("DATE_RECEIVED") public String dateReceived;
@JsonProperty("VALID_ADMIN_SIGNATURE") public String validAdminSignature;
@JsonProperty("VALID_SPONSOR_SIGNATURE") public String validSponsorSignature;
}
================================================
FILE: csv/src/test/java/perf/F5500Reader.java
================================================
package perf;
import java.io.File;
import java.io.IOException;
import java.util.Map;
import tools.jackson.databind.MappingIterator;
import tools.jackson.dataformat.csv.CsvMapper;
import tools.jackson.dataformat.csv.CsvSchema;
/**
* Manual test for checking how fast a F-5500 file
* (from http:///www.dol.gov/) can be read from a file
*/
public final class F5500Reader
{
public static void main(String[] args) throws Exception
{
if (args.length != 1) {
System.err.println("Usage: java .... [input file]");
System.exit(1);
}
new F5500Reader().read(new File(args[0]));
}
private void read(File inputFile) throws IOException, InterruptedException
{
int x = 1;
while (true) {
Class cls = ((x & 1) == 0) ? Map.class : F5500Entry.class;
++x;
long now = System.currentTimeMillis();
int count = readAll(inputFile, cls);
long time = System.currentTimeMillis() - now;
System.out.printf("DONE! Read %d rows as %s in %.1f seconds.\n",
count, cls.getName(), time / 1000.0);
Thread.sleep(500L);
}
}
private
* reader(pojoType).withSchema(schemaFor(pojoType));
*
* that is, constructs a {@link ObjectReader} which both binds to
* specified type and uses "loose" {@link CsvSchema} introspected from
* specified type (one without strict inferred typing).
*
* reader(pojoType).withSchema(typedSchemaFor(pojoType));
*
* that is, constructs a {@link ObjectReader} which both binds to
* specified type and uses "strict" {@link CsvSchema} introspected from
* specified type (one where typing is inferred).
*/
public ObjectReader readerWithTypedSchemaFor(Class pojoType)
{
JavaType type = constructType(pojoType);
// sanity check: not useful for structured types, since
// schema type will need to differ from data-bind type
if (type.isArrayType() || type.isCollectionLikeType()) {
throw new IllegalArgumentException("Type can NOT be a Collection or array type");
}
return readerFor(type).with(typedSchemaFor(type));
}
/*
/**********************************************************************
/* Additional ObjectWriter factory methods
/**********************************************************************
*/
/**
* Convenience method which is functionally equivalent to:
*
* writer(pojoType).with(schemaFor(pojoType));
*
* that is, constructs a {@link ObjectWriter} which both binds to
* specified type and uses "loose" {@link CsvSchema} introspected from
* specified type (one without strict inferred typing).
*
* writer(pojoType).with(typedSchemaFor(pojoType));
*
* that is, constructs a {@link ObjectWriter} which both binds to
* specified type and uses "strict" {@link CsvSchema} introspected from
* specified type (one where typing is inferred).
*/
public ObjectWriter writerWithTypedSchemaFor(Class pojoType)
{
JavaType type = constructType(pojoType);
// sanity check as per javadoc above
if (type.isArrayType() || type.isCollectionLikeType()) {
throw new IllegalArgumentException("Type can NOT be a Collection or array type");
}
return writerFor(type).with(typedSchemaFor(type));
}
/*
/**********************************************************************
/* CsvSchema construction; overrides, new methods
/**********************************************************************
*/
/**
* Convenience method that is same as
*
* CsvSchema.emptySchema().withHeader();
*
* and returns a {@link CsvSchema} instance that uses default configuration
* with additional setting that the first content line contains intended
* column names.
*/
public CsvSchema schemaWithHeader() {
return CsvSchema.emptySchema().withHeader();
}
/**
* Convenience method that is same as
*
* CsvSchema.emptySchema()
*
* that is, returns an "empty" Schema; one with default values and no
* column definitions.
*/
public CsvSchema schema() {
return CsvSchema.emptySchema();
}
/**
* Method that can be used to determine a CSV schema to use for given
* POJO type, using default serialization settings including ordering.
* Definition will not be strictly typed (that is, all columns are
* just defined to be exposed as String tokens).
*STATE_
* constants.
*/
protected int _state = STATE_DOC_START;
/**
* We will hold on to decoded binary data, for duration of
* current event, so that multiple calls to
* {@link #getBinaryValue} will not need to decode data more
* than once.
*/
protected byte[] _binaryValue;
/**
* Pointer to the first character of the next array value to return.
*/
protected int _arrayValueStart;
/**
* Contents of the cell, to be split into distinct array values.
*/
protected String _arrayValue;
protected String _arraySeparator;
protected String _nullValue;
/*
/**********************************************************************
/* Helper objects
/**********************************************************************
*/
/**
* Thing that actually reads the CSV content
*/
protected final CsvDecoder _reader;
/**
* Buffer that contains contents of all values after processing
* of doubled-quotes, escaped characters.
*/
protected final TextBuffer _textBuffer;
protected ByteArrayBuilder _byteArrayBuilder;
/*
/**********************************************************************
/* Life-cycle
/**********************************************************************
*/
public CsvParser(ObjectReadContext readCtxt, IOContext ioCtxt,
int stdFeatures, int csvFeatures, CsvSchema schema,
Reader reader)
{
super(readCtxt, ioCtxt, stdFeatures);
if (reader == null) {
throw new IllegalArgumentException("Can not pass `null` as `java.io.Reader` to read from");
}
_formatFeatures = csvFeatures;
DupDetector dups = StreamReadFeature.STRICT_DUPLICATE_DETECTION.enabledIn(stdFeatures)
? DupDetector.rootDetector(this) : null;
_streamReadContext = SimpleStreamReadContext.createRootContext(dups);
_textBuffer = ioCtxt.constructReadConstrainedTextBuffer();
_reader = new CsvDecoder(ioCtxt, this, reader, schema, _textBuffer,
stdFeatures, csvFeatures);
_setSchema(schema);
_cfgEmptyStringAsNull = CsvReadFeature.EMPTY_STRING_AS_NULL.enabledIn(csvFeatures);
_cfgEmptyUnquotedStringAsNull = CsvReadFeature.EMPTY_UNQUOTED_STRING_AS_NULL.enabledIn(csvFeatures);
_cfgOnlyUnquotedNullValuesAsNull = CsvReadFeature.ONLY_UNQUOTED_NULL_VALUES_AS_NULL.enabledIn(csvFeatures);
_cfgEmptyStringAsMissing = CsvReadFeature.EMPTY_UNQUOTED_STRING_AS_MISSING.enabledIn(csvFeatures);
}
/*
/**********************************************************************
/* Versioned
/**********************************************************************
*/
@Override
public Version version() {
return PackageVersion.VERSION;
}
/*
/**********************************************************************
/* Overrides: capability introspection methods
/**********************************************************************
*/
@Override
public boolean canReadObjectId() { return false; }
@Override
public boolean canReadTypeId() { return false; }
// @since 3.2
@Override
public boolean willInternPropertyNames() { return false; }
@Override
public JacksonFeatureSetObjectMapper.readValues(...)
* and array of Objects convenient when binding to Lists or
* arrays of values.
*
*
* Null values will also be recognized during value reads.
* CsvSchema instances:
*
*
*/
public class CsvSchema
implements FormatSchema,
IterablewithXxx methods
* or {@link #rebuild} for creating {@link Builder})
* null is used as marker.
*/
public final static String DEFAULT_ANY_PROPERTY_NAME = null;
public final static char DEFAULT_QUOTE_CHAR = '"';
/**
* By default, nulls are written as empty Strings (""); and no coercion
* is performed from any String (higher level databind may, however,
* coerce Strings into Java nulls).
* To use automatic coercion on reading, null value must be set explicitly
* to empty String ("").
*/
public final static char[] DEFAULT_NULL_VALUE = null;
/**
* By default, no escape character is used -- this is denoted by
* int value that does not map to a valid character
*/
public final static int DEFAULT_ESCAPE_CHAR = -1;
public final static char[] DEFAULT_LINEFEED = "\n".toCharArray();
/*
/**********************************************************************
/* Constants, other
/**********************************************************************
*/
protected final static Column[] NO_COLUMNS = new Column[0];
/*
/**********************************************************************
/* Helper classes
/**********************************************************************
*/
/**
* Enumeration that defines optional type indicators that can be passed
* with schema. If used type is used to determine type of
* {@link tools.jackson.core.JsonToken}
* that column values are exposed as.
*/
public enum ColumnType
{
/**
* Default type if not explicitly defined; value will
* be presented as VALUE_STRING by parser,
* that is, no type-inference is performed, and value is
* not trimmed.
*null disables use of
* "any properties" (and they are either ignored, or an exception
* is thrown, depending on other settings); setting it to a non-null
* String value will expose all extra properties under one specified
* name.
*
* @since 2.7
*/
protected final String _anyPropertyName;
/**
* @since 2.7
*/
public CsvSchema(Column[] columns, int features,
char columnSeparator, int quoteChar, int escapeChar,
char[] lineSeparator, String arrayElementSeparator,
char[] nullValue, String anyPropertyName)
{
if (columns == null) {
columns = NO_COLUMNS;
} else {
columns = _link(columns);
}
_columns = columns;
_features = features;
_columnSeparator = columnSeparator;
_arrayElementSeparator = arrayElementSeparator;
_quoteChar = quoteChar;
_escapeChar = escapeChar;
_lineSeparator = lineSeparator;
_nullValue = nullValue;
_anyPropertyName = anyPropertyName;
// and then we may need to create a mapping
if (_columns.length == 0) {
_columnsByName = Collections.emptyMap();
} else {
_columnsByName = new LinkedHashMap<>(4 + _columns.length);
for (Column c : _columns) {
_columnsByName.put(c.getName(), c);
}
}
}
/**
* Copy constructor used for creating variants using
* withXxx() methods.
*/
protected CsvSchema(Column[] columns, int features,
char columnSeparator, int quoteChar, int escapeChar,
char[] lineSeparator, String arrayElementSeparator,
char[] nullValue,
MapsortedBy() methods.
*/
protected CsvSchema(CsvSchema base, Column[] columns)
{
_columns = _link(columns);
_features = base._features;
_columnSeparator = base._columnSeparator;
_quoteChar = base._quoteChar;
_escapeChar = base._escapeChar;
_lineSeparator = base._lineSeparator;
_arrayElementSeparator = base._arrayElementSeparator;
_nullValue = base._nullValue;
_anyPropertyName = base._anyPropertyName;
// and then we may need to create a mapping
if (_columns.length == 0) {
_columnsByName = Collections.emptyMap();
} else {
_columnsByName = new LinkedHashMap<>(4 + _columns.length);
for (Column c : _columns) {
_columnsByName.put(c.getName(), c);
}
}
}
/**
* Copy constructor used for creating variants for on/off features
*
* @since 2.5
*/
protected CsvSchema(CsvSchema base, int features) {
_columns = base._columns;
_features = features;
_columnSeparator = base._columnSeparator;
_quoteChar = base._quoteChar;
_escapeChar = base._escapeChar;
_lineSeparator = base._lineSeparator;
_arrayElementSeparator = base._arrayElementSeparator;
_nullValue = base._nullValue;
_anyPropertyName = base._anyPropertyName;
_columnsByName = base._columnsByName;
}
/**
* Helper method used for chaining columns together using next-linkage,
* as well as ensuring that indexes are correct.
*/
private static Column[] _link(Column[] orig)
{
int i = orig.length;
Column[] result = new Column[i];
Column prev = null;
for (; --i >= 0; ) {
Column curr = orig[i].withNext(i, prev);
result[i] = curr;
prev = curr;
}
return result;
}
public static Builder builder() {
return new Builder();
}
/**
* Accessor for creating a "default" CSV schema instance, with following
* settings:
*
*
*/
public static CsvSchema emptySchema() {
return builder().build();
}
/**
* Helper method for constructing Builder that can be used to create modified
* schema.
*/
public Builder rebuild() {
return new Builder(this);
}
/*
/**********************************************************************
/* Mutant factories
/**********************************************************************
*/
public CsvSchema withUseHeader(boolean state) {
return _withFeature(ENCODING_FEATURE_USE_HEADER, state);
}
/**
* Returns a clone of this instance with column reordering enabled or disabled.
* Only meaningful when used in combination with {@link #withHeader()}.
*
* schema.withHeader().withColumnReordering(true)
*
* Alternatively, if you do not need type information from the schema,
* use {@link CsvSchema#emptySchema()}{@code .withHeader()} which always
* builds its column definitions from the header line.
*
* @see #withColumnReordering(boolean)
*/
public CsvSchema withHeader() {
return _withFeature(ENCODING_FEATURE_USE_HEADER, true);
}
/**
* Helper method for constructing and returning schema instance that
* is similar to this one, except that it will not be using header line.
*/
public CsvSchema withoutHeader() {
return _withFeature(ENCODING_FEATURE_USE_HEADER, false);
}
public CsvSchema withSkipFirstDataRow(boolean state) {
return _withFeature(ENCODING_FEATURE_SKIP_FIRST_DATA_ROW, state);
}
/**
* Method to indicate whether "hash comments" are allowed
* for document described by this schema.
*
* @since 2.5
*/
public CsvSchema withAllowComments(boolean state) {
return _withFeature(ENCODING_FEATURE_ALLOW_COMMENTS, state);
}
/**
* Method to indicate that "hash comments" ARE allowed
* for document described by this schema.
*
* @since 2.5
*/
public CsvSchema withComments() {
return _withFeature(ENCODING_FEATURE_ALLOW_COMMENTS, true);
}
/**
* Method to indicate that "hash comments" are NOT allowed for document
* described by this schema.
*
* @since 2.5
*/
public CsvSchema withoutComments() {
return _withFeature(ENCODING_FEATURE_ALLOW_COMMENTS, false);
}
protected CsvSchema _withFeature(int feature, boolean state) {
int newFeatures = state ? (_features | feature) : (_features & ~feature);
return (newFeatures == _features) ? this : new CsvSchema(this, newFeatures);
}
public CsvSchema withColumnSeparator(char sep) {
return (_columnSeparator == sep) ? this :
new CsvSchema(_columns, _features,
sep, _quoteChar, _escapeChar, _lineSeparator, _arrayElementSeparator,
_nullValue, _columnsByName, _anyPropertyName);
}
public CsvSchema withQuoteChar(char c) {
return (_quoteChar == c) ? this :
new CsvSchema(_columns, _features,
_columnSeparator, c, _escapeChar, _lineSeparator,_arrayElementSeparator,
_nullValue, _columnsByName, _anyPropertyName);
}
public CsvSchema withoutQuoteChar() {
return (_quoteChar == -1) ? this :
new CsvSchema(_columns, _features,
_columnSeparator, -1, _escapeChar, _lineSeparator, _arrayElementSeparator,
_nullValue, _columnsByName, _anyPropertyName);
}
public CsvSchema withEscapeChar(char c) {
return (_escapeChar == c) ? this
: new CsvSchema(_columns, _features,
_columnSeparator, _quoteChar, c, _lineSeparator, _arrayElementSeparator,
_nullValue, _columnsByName, _anyPropertyName);
}
public CsvSchema withoutEscapeChar() {
return (_escapeChar == -1) ? this
: new CsvSchema(_columns, _features,
_columnSeparator, _quoteChar, -1, _lineSeparator, _arrayElementSeparator,
_nullValue, _columnsByName, _anyPropertyName);
}
/**
* @since 2.7
*/
public CsvSchema withArrayElementSeparator(String separator) {
String sep = separator == null ? "" : separator;
return (_arrayElementSeparator.equals(sep)) ? this : new CsvSchema(_columns, _features,
_columnSeparator, _quoteChar, _escapeChar, _lineSeparator, separator,
_nullValue, _columnsByName, _anyPropertyName);
}
/**
* @since 2.5
*/
public CsvSchema withoutArrayElementSeparator() {
return (_arrayElementSeparator.isEmpty()) ? this
: new CsvSchema(_columns, _features,
_columnSeparator, _quoteChar, _escapeChar, _lineSeparator, "",
_nullValue, _columnsByName, _anyPropertyName);
}
public CsvSchema withLineSeparator(String sep) {
return new CsvSchema(_columns, _features,
_columnSeparator, _quoteChar, _escapeChar, sep.toCharArray(),
_arrayElementSeparator, _nullValue, _columnsByName, _anyPropertyName);
}
/**
* @since 2.5
*/
public CsvSchema withNullValue(String nvl) {
return new CsvSchema(_columns, _features,
_columnSeparator, _quoteChar, _escapeChar, _lineSeparator,
_arrayElementSeparator,
(nvl == null) ? null : nvl.toCharArray(),
_columnsByName, _anyPropertyName);
}
public CsvSchema withoutColumns() {
return new CsvSchema(NO_COLUMNS, _features,
_columnSeparator, _quoteChar, _escapeChar, _lineSeparator, _arrayElementSeparator,
_nullValue, _columnsByName, _anyPropertyName);
}
/**
* Mutant factory method that will try to combine columns of this schema with those
* from `toAppend`, starting with columns of this instance, and ignoring
* duplicates (if any) from argument `toAppend`.
* All settings aside from column sets are copied from `this` instance.
*"a", "d", "c", "b"
*
* ordered with schema.sortedBy("a", "b");
* would result instance that columns in order:
*"a", "b", "d", "c"
*
*
* @since 2.4
*/
public CsvSchema sortedBy(String... columnNames)
{
LinkedHashMapnull,
* or explicitly set as such) will be returned as empty char[]
*
* @since 2.6
*/
public char[] getNullValueOrEmpty() {
if (_nullValue == null) {
return NO_CHARS;
}
return _nullValue;
}
/**
* @since 2.6
*/
public String getNullValueString() {
String str = _nullValueAsString;
if (str == null) {
if (_nullValue == null) {
return null;
}
str = (_nullValue.length == 0) ? "" : new String(_nullValue);
_nullValueAsString = str;
}
return str;
}
public boolean usesQuoteChar() { return _quoteChar >= 0; }
public boolean usesEscapeChar() { return _escapeChar >= 0; }
/**
* @since 2.5
*/
public boolean hasArrayElementSeparator() { return !_arrayElementSeparator.isEmpty(); }
/**
* @since 2.7
*/
public String getAnyPropertyName() { return _anyPropertyName; }
/*
/**********************************************************************
/* Public API, extended; column access
/**********************************************************************
*/
@Override
public Iterator
* 0 <= index < size()
*
*/
public Column column(int index) {
return _columns[index];
}
/**
* Method for finding index of a named column within this schema.
*
* @param name Name of column to find
* @return Index of the specified column, if one exists; {@code -1} if not
*
* @since 2.18
*/
public int columnIndex(String name) {
Column col = column(name);
return (col == null) ? -1 : col.getIndex();
}
/**
* @since 2.6
*/
public String columnName(int index) {
return _columns[index].getName();
}
public Column column(String name) {
return _columnsByName.get(name);
}
/**
* Case-insensitive variant of {@link #column(String)}: looks up a column
* by name, ignoring case differences.
*
* @param name Column name to look up (case-insensitive)
* @return Column with matching name, or {@code null} if not found
*
* @since 3.2
*/
public Column columnIgnoreCase(String name) {
// Try exact match first for efficiency
Column col = _columnsByName.get(name);
if (col != null) {
return col;
}
for (Column c : _columns) {
if (c.getName().equalsIgnoreCase(name)) {
return c;
}
}
return null;
}
/**
* Optimized variant where a hint is given as to likely index of the column
* name.
*
* @since 2.6
*/
public Column column(String name, int probableIndex) {
if (probableIndex < _columns.length) {
Column col = _columns[probableIndex];
if (col.hasName(name)) {
return col;
}
}
return _columnsByName.get(name);
}
/**
* Accessor for getting names of included columns, in the order they are
* included in the schema.
*
* @since 2.14
*/
public Listtrue, full
* check is made to only use quoting when it is strictly necessary;
* but when {@code false}, a faster but more conservative check
* is made, and possibly quoting is used for values that might not need it.
* Trade-off is basically between optimal/minimal quoting ({@code true}), and
* faster handling ({@code false}).
* Faster check involves only checking first N characters of value, as well
* as possible looser checks.
*java.lang.String
* valued POJO properties) should be forced to be quoted, regardless of whether they
* actually need this.
* Note that this feature has precedence over {@link #STRICT_CHECK_FOR_QUOTING}, when
* both would be applicable.
* Note that this setting does NOT affect quoting of typed values like {@code Number}s
* or {@code Boolean}s.
*/
ALWAYS_QUOTE_STRINGS(false),
/**
* Feature that determines whether values written as empty Strings (from java.lang.String
* valued POJO properties) should be forced to be quoted.
*/
ALWAYS_QUOTE_EMPTY_STRINGS(false),
/**
* Feature that determines whether String values with leading or trailing
* whitespace (any character {@code <= 0x0020}, including space and tab)
* should be forced to be quoted.
* This is useful for interoperability with CSV parsers that trim unquoted
* whitespace.
*\n
* and \r
instead of being echoed out. This is a compatibility feature for some
* parsers that can not read such output back in.
* _outputBuffer is recyclable (and
* needs to be returned to recycler once we are done) or not.
*/
protected boolean _bufferRecyclable;
/**
* Pointer to the next available char position in {@link #_outputBuffer}
*/
protected int _outputTail = 0;
/**
* Offset to index after the last valid index in {@link #_outputBuffer}.
* Typically same as length of the buffer.
*/
protected final int _outputEnd;
/**
* Let's keep track of how many bytes have been output, may prove useful
* when debugging. This does not include bytes buffered in
* the output buffer, just bytes that have been written using underlying
* stream writer.
*/
protected int _charsWritten;
/*
/**********************************************************************
/* Construction, (re)configuration
/**********************************************************************
*/
/**
* @since 3.2
*/
public CsvEncoder(IOContext ctxt, int csvFeatures, Writer out, CsvSchema schema,
CharacterEscapes esc, boolean useFastDoubleWriter,
int maxQuoteCheckChars)
{
_ioContext = ctxt;
_csvFeatures = csvFeatures;
_cfgUseFastDoubleWriter = useFastDoubleWriter;
_cfgOptimalQuoting = CsvWriteFeature.STRICT_CHECK_FOR_QUOTING.enabledIn(csvFeatures);
_cfgIncludeMissingTail = !CsvWriteFeature.OMIT_MISSING_TAIL_COLUMNS.enabledIn(_csvFeatures);
_cfgAlwaysQuoteStrings = CsvWriteFeature.ALWAYS_QUOTE_STRINGS.enabledIn(csvFeatures);
_cfgAlwaysQuoteEmptyStrings = CsvWriteFeature.ALWAYS_QUOTE_EMPTY_STRINGS.enabledIn(csvFeatures);
_cfgAlwaysQuoteNumbers = CsvWriteFeature.ALWAYS_QUOTE_NUMBERS.enabledIn(csvFeatures);
_cfgQuoteLeadingTrailingWhitespace = CsvWriteFeature.QUOTE_STRINGS_WITH_LEADING_TRAILING_WHITESPACE.enabledIn(csvFeatures);
_cfgEscapeQuoteCharWithEscapeChar = CsvWriteFeature.ESCAPE_QUOTE_CHAR_WITH_ESCAPE_CHAR.enabledIn(csvFeatures);
_cfgEscapeControlCharWithEscapeChar = CsvWriteFeature.ESCAPE_CONTROL_CHARS_WITH_ESCAPE_CHAR.enabledIn(csvFeatures);
_outputBuffer = ctxt.allocConcatBuffer();
_bufferRecyclable = true;
_outputEnd = _outputBuffer.length;
_out = out;
_cfgColumnSeparator = schema.getColumnSeparator();
_cfgQuoteCharacter = schema.getQuoteChar();
_cfgEscapeCharacter = schema.getEscapeChar();
_cfgLineSeparator = schema.getLineSeparator();
_cfgLineSeparatorLength = (_cfgLineSeparator == null) ? 0 : _cfgLineSeparator.length;
_cfgNullValue = schema.getNullValueOrEmpty();
_cfgAllowsComments = schema.allowsComments();
_columnCount = schema.size();
_outputEscapes = (esc == null) ? sOutputEscapes : esc.getEscapeCodesForAscii();
_cfgMinSafeChar = _calcSafeChar();
_cfgMaxQuoteCheckChars = maxQuoteCheckChars;
_cfgQuoteCharEscapeChar = _getQuoteCharEscapeChar(
_cfgEscapeQuoteCharWithEscapeChar,
_cfgQuoteCharacter,
_cfgEscapeCharacter
);
_cfgControlCharEscapeChar = _cfgEscapeCharacter > 0 ? (char) _cfgEscapeCharacter : '\\';
_verifyConfiguration(schema);
}
@Deprecated // @since 3.2
public CsvEncoder(IOContext ctxt, int csvFeatures, Writer out, CsvSchema schema,
CharacterEscapes esc, boolean useFastDoubleWriter)
{
this(ctxt, csvFeatures, out, schema, esc, useFastDoubleWriter,
DEFAULT_MAX_QUOTE_CHECK);
}
public CsvEncoder(CsvEncoder base, CsvSchema newSchema)
{
_ioContext = base._ioContext;
_csvFeatures = base._csvFeatures;
_cfgUseFastDoubleWriter = base._cfgUseFastDoubleWriter;
_cfgOptimalQuoting = base._cfgOptimalQuoting;
_cfgIncludeMissingTail = base._cfgIncludeMissingTail;
_cfgAlwaysQuoteStrings = base._cfgAlwaysQuoteStrings;
_cfgAlwaysQuoteEmptyStrings = base._cfgAlwaysQuoteEmptyStrings;
_cfgAlwaysQuoteNumbers = base._cfgAlwaysQuoteNumbers;
_cfgQuoteLeadingTrailingWhitespace = base._cfgQuoteLeadingTrailingWhitespace;
_cfgEscapeQuoteCharWithEscapeChar = base._cfgEscapeQuoteCharWithEscapeChar;
_cfgEscapeControlCharWithEscapeChar = base._cfgEscapeControlCharWithEscapeChar;
_outputBuffer = base._outputBuffer;
_bufferRecyclable = base._bufferRecyclable;
_outputEnd = base._outputEnd;
_out = base._out;
_cfgMaxQuoteCheckChars = base._cfgMaxQuoteCheckChars;
_outputEscapes = base._outputEscapes;
_cfgColumnSeparator = newSchema.getColumnSeparator();
_cfgQuoteCharacter = newSchema.getQuoteChar();
_cfgEscapeCharacter = newSchema.getEscapeChar();
_cfgLineSeparator = newSchema.getLineSeparator();
_cfgLineSeparatorLength = _cfgLineSeparator.length;
_cfgNullValue = newSchema.getNullValueOrEmpty();
_cfgAllowsComments = newSchema.allowsComments();
_cfgMinSafeChar = _calcSafeChar();
_columnCount = newSchema.size();
_cfgQuoteCharEscapeChar = _getQuoteCharEscapeChar(
base._cfgEscapeQuoteCharWithEscapeChar,
newSchema.getQuoteChar(),
newSchema.getEscapeChar()
);
_cfgControlCharEscapeChar = _cfgEscapeCharacter > 0 ? (char) _cfgEscapeCharacter : '\\';
_verifyConfiguration(newSchema);
}
private void _verifyConfiguration(CsvSchema schema)
{
// 21-Feb-2023, tatu: [dataformats-text#374]: Need to verify that Escape character
// is defined if need to use it
if (_cfgEscapeQuoteCharWithEscapeChar || _cfgEscapeControlCharWithEscapeChar) {
if (!schema.usesEscapeChar()) {
throw CsvWriteException.from(null,
"Cannot use `CsvGenerator.Feature.ESCAPE_QUOTE_CHAR_WITH_ESCAPE_CHAR` or `CsvGenerator.Feature.ESCAPE_CONTROL_CHARS_WITH_ESCAPE_CHAR`"
+" if no escape character defined in `CsvSchema`",
schema);
}
}
}
private final char _getQuoteCharEscapeChar(
final boolean escapeQuoteCharWithEscapeChar,
final int quoteCharacter,
final int escapeCharacter)
{
final char quoteEscapeChar;
if (escapeQuoteCharWithEscapeChar && escapeCharacter > 0) {
quoteEscapeChar = (char) escapeCharacter;
}
else if (quoteCharacter > 0) {
quoteEscapeChar = (char) quoteCharacter;
}
else {
quoteEscapeChar = '\\';
}
return quoteEscapeChar;
}
private final int _calcSafeChar()
{
// note: quote char may be -1 to signify "no quoting":
int min = Math.max(_cfgColumnSeparator, _cfgQuoteCharacter);
// 06-Nov-2015, tatu: We will NOT apply escape character, because it usually
// has higher ascii value (with backslash); better handle separately.
// 23-Sep-2020, tatu: Should not actually need to consider anything but the
// first character when checking... but leaving rest for now
for (int i = 0; i < _cfgLineSeparatorLength; ++i) {
min = Math.max(min, _cfgLineSeparator[i]);
}
return min+1;
}
public CsvEncoder withSchema(CsvSchema schema) {
return new CsvEncoder(this, schema);
}
public CsvEncoder setOutputEscapes(int[] esc) {
_outputEscapes = (esc != null) ? esc : sOutputEscapes;
return this;
}
/*
/**********************************************************************
/* Read-access to output state
/**********************************************************************
*/
public Object getOutputTarget() {
return _out;
}
/**
* NOTE: while value does indeed indicate amount that has been written in the buffer,
* there may be more intermediate data that is buffered as values but not yet in
* buffer.
*/
public int getOutputBuffered() {
return _outputTail;
}
public int nextColumnIndex() {
return _nextColumnToWrite;
}
/*
/**********************************************************************
/* Writer API, writes from generator
/**********************************************************************
*/
public final void write(int columnIndex, String value) throws JacksonException
{
// easy case: all in order
if (columnIndex == _nextColumnToWrite) {
// inlined 'appendValue(String)`
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
appendColumnSeparator();
}
final int len = value.length();
if (_cfgAlwaysQuoteStrings || _mayNeedQuotes(value, len, columnIndex)) {
if (_cfgEscapeCharacter > 0) {
_writeQuotedAndEscaped(value, (char) _cfgEscapeCharacter);
} else {
_writeQuoted(value);
}
} else {
writeRaw(value);
}
++_nextColumnToWrite;
return;
}
_buffer(columnIndex, BufferedValue.buffered(value));
}
public final void write(int columnIndex, char[] ch, int offset, int len) throws JacksonException
{
// !!! TODO: optimize
write(columnIndex, new String(ch, offset, len));
}
public final void write(int columnIndex, int value) throws JacksonException
{
// easy case: all in order
if (columnIndex == _nextColumnToWrite) {
// inlined 'appendValue(int)'
// up to 10 digits and possible minus sign, leading comma, possible quotes
if ((_outputTail + 14) > _outputEnd) {
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
_outputBuffer[_outputTail++] = _cfgColumnSeparator;
}
if (_cfgAlwaysQuoteNumbers) {
_outputBuffer[_outputTail++] = (char) _cfgQuoteCharacter;
}
_outputTail = NumberOutput.outputInt(value, _outputBuffer, _outputTail);
if (_cfgAlwaysQuoteNumbers) {
_outputBuffer[_outputTail++] = (char) _cfgQuoteCharacter;
}
++_nextColumnToWrite;
return;
}
_buffer(columnIndex, BufferedValue.buffered(value));
}
public final void write(int columnIndex, long value) throws JacksonException
{
// easy case: all in order
if (columnIndex == _nextColumnToWrite) {
// inlined 'appendValue(int)'
// up to 20 digits, minus sign, leading comma, possible quotes
if ((_outputTail + 24) > _outputEnd) {
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
_outputBuffer[_outputTail++] = _cfgColumnSeparator;
}
if (_cfgAlwaysQuoteNumbers) {
_outputBuffer[_outputTail++] = (char) _cfgQuoteCharacter;
}
_outputTail = NumberOutput.outputLong(value, _outputBuffer, _outputTail);
if (_cfgAlwaysQuoteNumbers) {
_outputBuffer[_outputTail++] = (char) _cfgQuoteCharacter;
}
++_nextColumnToWrite;
return;
}
_buffer(columnIndex, BufferedValue.buffered(value));
}
public final void write(int columnIndex, BigInteger value) throws JacksonException
{
// easy case: all in order
final String numStr = value.toString();
if (columnIndex == _nextColumnToWrite) {
appendNumberValue(numStr);
++_nextColumnToWrite;
return;
}
_buffer(columnIndex, BufferedValue.bufferedNumber(numStr));
}
public final void write(int columnIndex, float value) throws JacksonException
{
// easy case: all in order
if (columnIndex == _nextColumnToWrite) {
appendValue(value);
++_nextColumnToWrite;
return;
}
_buffer(columnIndex, BufferedValue.buffered(value));
}
public final void write(int columnIndex, double value) throws JacksonException
{
// easy case: all in order
if (columnIndex == _nextColumnToWrite) {
appendValue(value);
++_nextColumnToWrite;
return;
}
_buffer(columnIndex, BufferedValue.buffered(value));
}
public final void write(int columnIndex, BigDecimal value, boolean plain) throws JacksonException
{
final String numStr = plain ? value.toPlainString() : value.toString();
// easy case: all in order
if (columnIndex == _nextColumnToWrite) {
appendNumberValue(numStr);
++_nextColumnToWrite;
return;
}
_buffer(columnIndex, BufferedValue.bufferedNumber(numStr));
}
public final void write(int columnIndex, boolean value) throws JacksonException
{
// easy case: all in order
if (columnIndex == _nextColumnToWrite) {
appendValue(value);
++_nextColumnToWrite;
return;
}
_buffer(columnIndex, BufferedValue.buffered(value));
}
public final void writeNonEscaped(int columnIndex, String rawValue) throws JacksonException
{
if (columnIndex == _nextColumnToWrite) {
appendRawValue(rawValue);
++_nextColumnToWrite;
return;
}
_buffer(columnIndex, BufferedValue.bufferedRaw(rawValue));
}
public final void writeNull(int columnIndex) throws JacksonException
{
if (columnIndex == _nextColumnToWrite) {
appendNull();
++_nextColumnToWrite;
return;
}
_buffer(columnIndex, BufferedValue.bufferedNull());
}
public final void writeColumnName(String name) throws JacksonException
{
appendValue(name);
++_nextColumnToWrite;
}
public void endRow() throws JacksonException
{
// First things first; any buffered?
if (_lastBuffered >= 0) {
final int last = _lastBuffered;
_lastBuffered = -1;
for (; _nextColumnToWrite <= last; ++_nextColumnToWrite) {
BufferedValue value = _buffered[_nextColumnToWrite];
if (value != null) {
_buffered[_nextColumnToWrite] = null;
value.write(this);
} else if (_nextColumnToWrite > 0) { // ) {
// note: write method triggers prepending of separator; but for missing
// values we need to do it explicitly.
appendColumnSeparator();
}
}
} else if (_nextColumnToWrite <= 0) { // empty line; do nothing
return;
}
// Any missing values?
if (_nextColumnToWrite < _columnCount) {
if (_cfgIncludeMissingTail) {
do {
appendColumnSeparator();
} while (++_nextColumnToWrite < _columnCount);
}
}
// write line separator
_nextColumnToWrite = 0;
if ((_outputTail + _cfgLineSeparatorLength) > _outputEnd) {
_flushBuffer();
}
System.arraycopy(_cfgLineSeparator, 0, _outputBuffer, _outputTail, _cfgLineSeparatorLength);
_outputTail += _cfgLineSeparatorLength;
}
/*
/**********************************************************************
/* Writer API, writes via buffered values
/**********************************************************************
*/
protected void appendValue(String value) throws JacksonException
{
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
appendColumnSeparator();
}
// First: determine if we need quotes; simple heuristics;
// only check for short Strings, stop if something found
final int len = value.length();
if (_cfgAlwaysQuoteStrings || _mayNeedQuotes(value, len, _nextColumnToWrite)) {
if (_cfgEscapeCharacter > 0) {
_writeQuotedAndEscaped(value, (char) _cfgEscapeCharacter);
} else {
_writeQuoted(value);
}
} else {
writeRaw(value);
}
}
protected void appendRawValue(String value) throws JacksonException
{
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
appendColumnSeparator();
}
writeRaw(value);
}
protected void appendValue(int value) throws JacksonException
{
// up to 10 digits and possible minus sign, leading comma, possible quotes
if ((_outputTail + 14) > _outputEnd) {
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
_outputBuffer[_outputTail++] = _cfgColumnSeparator;
}
if (_cfgAlwaysQuoteNumbers) {
_outputBuffer[_outputTail++] = (char) _cfgQuoteCharacter;
}
_outputTail = NumberOutput.outputInt(value, _outputBuffer, _outputTail);
if (_cfgAlwaysQuoteNumbers) {
_outputBuffer[_outputTail++] = (char) _cfgQuoteCharacter;
}
}
protected void appendValue(long value) throws JacksonException
{
// up to 20 digits, minus sign, leading comma, possible quotes
if ((_outputTail + 24) > _outputEnd) {
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
_outputBuffer[_outputTail++] = _cfgColumnSeparator;
}
if (_cfgAlwaysQuoteNumbers) {
_outputBuffer[_outputTail++] = (char) _cfgQuoteCharacter;
}
_outputTail = NumberOutput.outputLong(value, _outputBuffer, _outputTail);
if (_cfgAlwaysQuoteNumbers) {
_outputBuffer[_outputTail++] = (char) _cfgQuoteCharacter;
}
}
protected void appendValue(float value) throws JacksonException
{
String str = NumberOutput.toString(value, _cfgUseFastDoubleWriter);
final int len = str.length();
if ((_outputTail + len) >= _outputEnd) { // >= to include possible comma too
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
_outputBuffer[_outputTail++] = _cfgColumnSeparator;
}
writeNumber(str);
}
protected void appendValue(double value) throws JacksonException
{
String str = NumberOutput.toString(value, _cfgUseFastDoubleWriter);
final int len = str.length();
if ((_outputTail + len) >= _outputEnd) { // >= to include possible comma too
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
_outputBuffer[_outputTail++] = _cfgColumnSeparator;
}
writeNumber(str);
}
// @since 2.16: pre-encoded BigInteger/BigDecimal value
protected void appendNumberValue(String numStr) throws JacksonException
{
// Same as "appendRawValue()", except may want quoting
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
appendColumnSeparator();
}
writeNumber(numStr);
}
protected void appendValue(boolean value) throws JacksonException {
_append(value ? TRUE_CHARS : FALSE_CHARS);
}
protected void appendNull() throws JacksonException {
_append(_cfgNullValue);
}
protected void _append(char[] ch) throws JacksonException {
final int len = ch.length;
if ((_outputTail + len) >= _outputEnd) { // >= to include possible comma too
_flushBuffer();
}
if (_nextColumnToWrite > 0) {
_outputBuffer[_outputTail++] = _cfgColumnSeparator;
}
if (len > 0) {
System.arraycopy(ch, 0, _outputBuffer, _outputTail, len);
}
_outputTail += len;
}
protected void appendColumnSeparator() throws JacksonException {
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
_outputBuffer[_outputTail++] = _cfgColumnSeparator;
}
/*
/**********************************************************************
/* Output methods, unprocessed ("raw")
/**********************************************************************
*/
public void writeRaw(String text) throws JacksonException
{
// Nothing to check, can just output as is
int len = text.length();
int room = _outputEnd - _outputTail;
if (room == 0) {
_flushBuffer();
room = _outputEnd - _outputTail;
}
// But would it nicely fit in? If yes, it's easy
if (room >= len) {
text.getChars(0, len, _outputBuffer, _outputTail);
_outputTail += len;
} else {
writeRawLong(text);
}
}
public void writeRaw(String text, int start, int len) throws JacksonException
{
// Nothing to check, can just output as is
int room = _outputEnd - _outputTail;
if (room < len) {
_flushBuffer();
room = _outputEnd - _outputTail;
}
// But would it nicely fit in? If yes, it's easy
if (room >= len) {
text.getChars(start, start+len, _outputBuffer, _outputTail);
_outputTail += len;
} else {
writeRawLong(text.substring(start, start+len));
}
}
public void writeRaw(char[] text, int offset, int len) throws JacksonException
{
// Only worth buffering if it's a short write?
if (len < SHORT_WRITE) {
int room = _outputEnd - _outputTail;
if (len > room) {
_flushBuffer();
}
System.arraycopy(text, offset, _outputBuffer, _outputTail, len);
_outputTail += len;
return;
}
// Otherwise, better just pass through:
_flushBuffer();
try {
_out.write(text, offset, len);
} catch (IOException e) {
throw _wrapIOFailure(e);
}
}
public void writeRaw(char c) throws JacksonException
{
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
_outputBuffer[_outputTail++] = c;
}
private void writeRawLong(String text) throws JacksonException
{
int room = _outputEnd - _outputTail;
// If not, need to do it by looping
text.getChars(0, room, _outputBuffer, _outputTail);
_outputTail += room;
_flushBuffer();
int offset = room;
int len = text.length() - room;
while (len > _outputEnd) {
int amount = _outputEnd;
text.getChars(offset, offset+amount, _outputBuffer, 0);
_outputTail = amount;
_flushBuffer();
offset += amount;
len -= amount;
}
// And last piece (at most length of buffer)
text.getChars(offset, offset+len, _outputBuffer, 0);
_outputTail = len;
}
// @since 2.16
private void writeNumber(String text) throws JacksonException
{
final int len = text.length();
if ((_outputTail + len + 2) > _outputEnd) {
_flushBuffer();
}
if (_cfgAlwaysQuoteNumbers) {
_outputBuffer[_outputTail++] = (char) _cfgQuoteCharacter;
text.getChars(0, len, _outputBuffer, _outputTail);
_outputTail += len;
_outputBuffer[_outputTail++] = (char) _cfgQuoteCharacter;
} else {
text.getChars(0, len, _outputBuffer, _outputTail);
_outputTail += len;
}
}
/*
/**********************************************************************
/* Output methods, with quoting and escaping
/**********************************************************************
*/
public void _writeQuoted(String text) throws JacksonException
{
final int[] escCodes = _outputEscapes;
final int escLen = escCodes.length;
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
// NOTE: caller should guarantee quote char is valid (not -1) at this point:
final char q = (char) _cfgQuoteCharacter;
_outputBuffer[_outputTail++] = q;
// simple case: if we have enough room, no need for boundary checks
final int len = text.length();
if ((_outputTail + len + len) >= _outputEnd) {
_writeLongQuoted(text, q);
return;
}
// 22-Jan-2015, tatu: Common case is that of no quoting needed, so let's
// make a speculative copy, then scan
// 06-Nov-2015, tatu: Not sure if copy actually improves perf; it did with
// older JVMs (1.5 at least), but not sure about 1.8 and later
final char[] buf = _outputBuffer;
int ptr = _outputTail;
text.getChars(0, len, buf, ptr);
final int end = ptr+len;
for (; ptr < end; ++ptr) {
char c = buf[ptr];
// see if any of the characters need escaping.
// if yes, fall back to the more convoluted write method
if ((c == q) || (c < escLen && escCodes[c] != 0)) {
break; // for
}
}
if (ptr == end) { // all good, no quoting or escaping!
_outputBuffer[ptr] = q;
_outputTail = ptr+1;
} else { // doh. do need quoting
_writeQuoted(text, q, ptr - _outputTail);
}
}
protected void _writeQuoted(String text, char q, int i) throws JacksonException
{
final int[] escCodes = _outputEscapes;
final int escLen = escCodes.length;
final char[] buf = _outputBuffer;
_outputTail += i;
final int len = text.length();
for (; i < len; ++i) {
char c = text.charAt(i);
if (c < escLen) {
int escCode = escCodes[c];
if (escCode != 0) { // for escape control and double quotes, c will be 0
_appendCharacterEscape(c, escCode);
continue; // for
}
}
if (c == q) { // double up
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
buf[_outputTail++] = _cfgQuoteCharEscapeChar; // this will be the quote
}
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
buf[_outputTail++] = c;
}
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
buf[_outputTail++] = q;
}
private final void _writeLongQuoted(String text, char q) throws JacksonException
{
final int[] escCodes = _outputEscapes;
final int escLen = escCodes.length;
final int len = text.length();
for (int i = 0; i < len; ++i) {
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
char c = text.charAt(i);
if (c < escLen) {
int escCode = escCodes[c];
if (escCode != 0) { // for escape control and double quotes, c will be 0
_appendCharacterEscape(c, escCode);
continue; // for
}
}
if (c == q) { // double up
_outputBuffer[_outputTail++] = _cfgQuoteCharEscapeChar;
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
}
_outputBuffer[_outputTail++] = c;
}
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
_outputBuffer[_outputTail++] = q;
}
public void _writeQuotedAndEscaped(String text, char esc) throws JacksonException
{
final int[] escCodes = _outputEscapes;
final int escLen = escCodes.length;
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
// NOTE: caller should guarantee quote char is valid (not -1) at this point:
final char q = (char) _cfgQuoteCharacter;
_outputBuffer[_outputTail++] = q;
final int len = text.length();
if ((_outputTail + len + len) >= _outputEnd) {
_writeLongQuotedAndEscaped(text, esc);
return;
}
final char[] buf = _outputBuffer;
int ptr = _outputTail;
text.getChars(0, len, buf, ptr);
final int end = ptr+len;
for (; ptr < end; ++ptr) {
char c = buf[ptr];
if ((c == q) || (c == esc) || (c < escLen && escCodes[c] != 0)) {
break;
}
}
if (ptr == end) { // all good, no quoting or escaping!
_outputBuffer[ptr] = q;
_outputTail = ptr+1;
} else { // quoting AND escaping
_writeQuotedAndEscaped(text, q, esc, ptr - _outputTail);
}
}
protected void _writeQuotedAndEscaped(String text, char q, char esc, int i) throws JacksonException
{
final int[] escCodes = _outputEscapes;
final int escLen = escCodes.length;
final char[] buf = _outputBuffer;
_outputTail += i;
final int len = text.length();
for (; i < len; ++i) {
char c = text.charAt(i);
if (c < escLen) {
int escCode = escCodes[c];
if (escCode != 0) { // for escape control and double quotes, c will be 0
_appendCharacterEscape(c, escCode);
continue; // for
}
}
if (c == q) { // double up
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
_outputBuffer[_outputTail++] = _cfgQuoteCharEscapeChar;
} else if (c == esc) { // double up
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
_outputBuffer[_outputTail++] = _cfgControlCharEscapeChar;
}
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
buf[_outputTail++] = c;
}
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
buf[_outputTail++] = q;
}
private final void _writeLongQuotedAndEscaped(String text, char esc) throws JacksonException
{
final int[] escCodes = _outputEscapes;
final int escLen = escCodes.length;
final int len = text.length();
// NOTE: caller should guarantee quote char is valid (not -1) at this point:
final char q = (char) _cfgQuoteCharacter;
// 23-Sep-2020, tatu: Why was this defined but not used? Commented out in 2.11.3
// final char quoteEscape = _cfgEscapeQuoteCharWithEscapeChar ? esc : q;
for (int i = 0; i < len; ++i) {
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
char c = text.charAt(i);
if (c < escLen) {
int escCode = escCodes[c];
if (escCode != 0) { // for escape control and double quotes, c will be 0
_appendCharacterEscape(c, escCode);
continue; // for
}
}
if (c == q) { // double up
_outputBuffer[_outputTail++] = _cfgQuoteCharEscapeChar;
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
} else if (c == esc) { // double up
_outputBuffer[_outputTail++] = _cfgControlCharEscapeChar;
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
}
_outputBuffer[_outputTail++] = c;
}
if (_outputTail >= _outputEnd) {
_flushBuffer();
}
_outputBuffer[_outputTail++] = q;
}
/*
/**********************************************************************
/* Writer API, state changes
/**********************************************************************
*/
public void flush(boolean flushStream) throws IOException
{
_flushBuffer();
if (flushStream) {
_out.flush();
}
}
public void close(boolean autoClose, boolean flushStream) throws IOException
{
// May need to remove the linefeed appended after the last row written
// (if not yet done)
if (!CsvWriteFeature.WRITE_LINEFEED_AFTER_LAST_ROW.enabledIn(_csvFeatures)) {
_removeTrailingLF();
}
try {
_flushBuffer();
} finally {
if (autoClose) {
_out.close();
} else if (flushStream) {
// If we can't close it, we should at least flush
_out.flush();
}
// Internal buffer(s) generator has can now be released as well
_releaseBuffers();
}
}
private void _removeTrailingLF() throws IOException {
if (!_trailingLFRemoved) {
_trailingLFRemoved = true;
// Remove trailing LF if (but only if) it appears to be in output
// buffer (may not be possible if `flush()` has been called)
_outputTail = Math.max(0, _outputTail - _cfgLineSeparatorLength);
}
}
/*
/**********************************************************************
/* Internal methods
/**********************************************************************
*/
/**
* Helper method that determines whether given String is likely
* to require quoting; check tries to optimize for speed.
*/
protected boolean _mayNeedQuotes(String value, int length, int columnIndex)
{
// 21-Mar-2014, tatu: If quoting disabled, don't quote
if (_cfgQuoteCharacter < 0) {
return false;
}
// [dataformats-text#210]: check for leading/trailing whitespace
if (_cfgQuoteLeadingTrailingWhitespace && length > 0) {
char first = value.charAt(0);
char last = value.charAt(length - 1);
if (first <= ' ' || last <= ' ') {
return true;
}
}
// may skip checks unless we want exact checking
if (_cfgOptimalQuoting) {
// 31-Dec-2014, tatu: Comment lines start with # so quote if starts with #
// 28-May-2021, tatu: As per [dataformats-text#270] only check if first column
if (_cfgAllowsComments && (columnIndex == 0)
&& (length > 0) && (value.charAt(0) == '#')) {
return true;
}
if (_cfgEscapeCharacter > 0) {
return _needsQuotingStrict(value, _cfgEscapeCharacter);
}
return _needsQuotingStrict(value);
}
if (length > _cfgMaxQuoteCheckChars) {
return true;
}
if (_cfgEscapeCharacter > 0) {
return _needsQuotingLoose(value, _cfgEscapeCharacter);
}
if (_cfgAlwaysQuoteEmptyStrings && length == 0) {
return true;
}
return _needsQuotingLoose(value);
}
/**
* @since 2.4
*/
protected final boolean _needsQuotingLoose(String value)
{
char esc1 = _cfgQuoteCharEscapeChar;
char esc2 = _cfgControlCharEscapeChar;
for (int i = 0, len = value.length(); i < len; ++i) {
char c = value.charAt(i);
if ((c < _cfgMinSafeChar)
|| (c == esc1)
|| (c == esc2)) {
return true;
}
}
return false;
}
protected final boolean _needsQuotingLoose(String value, int esc)
{
for (int i = 0, len = value.length(); i < len; ++i) {
int ch = value.charAt(i);
if ((ch < _cfgMinSafeChar) || (ch == esc)) {
return true;
}
}
return false;
}
protected boolean _needsQuotingStrict(String value)
{
final int minSafe = _cfgMinSafeChar;
final int[] escCodes = _outputEscapes;
final int escLen = escCodes.length;
// 23-Sep-2020, tatu: [dataformats-text#217] Must also ensure line separator
// leads to quoting
// 17-Dec-2025, tatu: [dataformats-text#479] Must check for ALL line separators
// (LF, CR) per RFC 4180, not just the configured schema line separator.
// NOTE: escCodes is empty by default (unless custom CharacterEscapes provided),
// so we cannot rely on `escCodes[c] != 0` check to catch newlines - we must
// check for them explicitly.
final int lfFirst = (_cfgLineSeparatorLength == 0) ? 0 : _cfgLineSeparator[0];
for (int i = 0, len = value.length(); i < len; ++i) {
int c = value.charAt(i);
if (c < minSafe) {
if (c == _cfgColumnSeparator || c == _cfgQuoteCharacter
|| (c < escLen && escCodes[c] != 0)
|| (c == lfFirst)
// Per RFC 4180: must quote if contains LF or CR
|| (c == '\n') || (c == '\r')) {
return true;
}
}
}
return false;
}
protected boolean _needsQuotingStrict(String value, int esc)
{
final int minSafe = _cfgMinSafeChar;
final int[] escCodes = _outputEscapes;
final int escLen = escCodes.length;
// 23-Sep-2020, tatu: [dataformats-text#217] Must also ensure line separator
// leads to quoting
// 17-Dec-2025, tatu: [dataformats-text#479] Must check for ALL line separators
// (LF, CR) per RFC 4180, not just the configured schema line separator.
// NOTE: escCodes is empty by default (unless custom CharacterEscapes provided),
// so we cannot rely on `escCodes[c] != 0` check to catch newlines - we must
// check for them explicitly.
final int lfFirst = (_cfgLineSeparatorLength == 0) ? 0 : _cfgLineSeparator[0];
for (int i = 0, len = value.length(); i < len; ++i) {
int c = value.charAt(i);
if (c < minSafe) {
if (c == _cfgColumnSeparator || c == _cfgQuoteCharacter
|| (c < escLen && escCodes[c] != 0)
|| (c == lfFirst)
// Per RFC 4180: must quote if contains LF or CR
|| (c == '\n') || (c == '\r')) {
return true;
}
} else if (c == esc) {
return true;
}
}
return false;
}
protected void _buffer(int index, BufferedValue v)
{
_lastBuffered = Math.max(_lastBuffered, index);
if (index >= _buffered.length) {
_buffered = Arrays.copyOf(_buffered, Math.max(index+1, _columnCount));
}
_buffered[index] = v;
}
protected void _flushBuffer() throws JacksonException
{
if (_outputTail > 0) {
_charsWritten += _outputTail;
try {
_out.write(_outputBuffer, 0, _outputTail);
} catch (IOException e) {
throw _wrapIOFailure(e);
}
_outputTail = 0;
}
}
public void _releaseBuffers()
{
char[] buf = _outputBuffer;
if (buf != null && _bufferRecyclable) {
_outputBuffer = null;
_ioContext.releaseConcatBuffer(buf);
}
}
/**
* Method called to append escape sequence for given character, at the
* end of standard output buffer; or if not possible, write out directly.
*/
private void _appendCharacterEscape(char ch, int escCode)
throws JacksonException
{
if (escCode >= 0) { // \\N (2 char)
if ((_outputTail + 2) > _outputEnd) {
_flushBuffer();
}
_outputBuffer[_outputTail++] = _cfgControlCharEscapeChar;
_outputBuffer[_outputTail++] = (char) escCode;
return;
}
if ((_outputTail + 5) >= _outputEnd) {
_flushBuffer();
}
int ptr = _outputTail;
char[] buf = _outputBuffer;
buf[ptr++] = '\\';
buf[ptr++] = 'u';
// We know it's a control char, so only the last 2 chars are non-0
if (ch > 0xFF) { // beyond 8 bytes
int hi = (ch >> 8) & 0xFF;
buf[ptr++] = HEX_CHARS[hi >> 4];
buf[ptr++] = HEX_CHARS[hi & 0xF];
ch &= 0xFF;
} else {
buf[ptr++] = '0';
buf[ptr++] = '0';
}
buf[ptr++] = HEX_CHARS[ch >> 4];
buf[ptr++] = HEX_CHARS[ch & 0xF];
_outputTail = ptr;
return;
}
// @since 3.0: defined by basic JsonParser/JsonGenerator but since we are
// not extending need to copy here
protected JacksonException _wrapIOFailure(IOException e) {
return JacksonIOException.construct(e);
}
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/impl/CsvParserBootstrapper.java
================================================
package tools.jackson.dataformat.csv.impl;
import java.io.*;
import tools.jackson.core.*;
import tools.jackson.core.exc.JacksonIOException;
import tools.jackson.core.io.IOContext;
import tools.jackson.core.io.MergedStream;
import tools.jackson.core.io.UTF32Reader;
import tools.jackson.dataformat.csv.CsvParser;
import tools.jackson.dataformat.csv.CsvSchema;
/**
* This class is used to determine the encoding of byte stream
* that is to contain CSV document.
* Since there is no real specification for how this should work
* with CSV, it will be based on rules used with JSON (which themselves
* are similar to those used with XML); main points are to check for
* BOM first, then look for multi-byted fixed-length encodings
* (UTF-16, UTF-32). And finally, if neither found, must decide
* between most likely alternatives, UTF-8 and Latin-1.
*/
public final class CsvParserBootstrapper
{
final static byte UTF8_BOM_1 = (byte) 0xEF;
final static byte UTF8_BOM_2 = (byte) 0xBB;
final static byte UTF8_BOM_3 = (byte) 0xBF;
/*
/**********************************************************************
/* Configuration
/**********************************************************************
*/
protected final IOContext _context;
/*
/**********************************************************************
/* Input buffering
/**********************************************************************
*/
protected final InputStream _in;
protected final byte[] _inputBuffer;
private int _inputPtr;
private int _inputEnd;
/*
/**********************************************************************
/* Input location
/**********************************************************************
*/
/**
* Current number of input units (bytes or chars) that were processed in
* previous blocks,
* before contents of current input buffer.
*mByteBufferEnd
*/
private int _inputPtr;
/**
* Pointed to the end marker, that is, position one after the last
* valid available byte.
*/
private int _inputEnd;
/**
* Decoded first character of a surrogate pair, if one needs to be buffered
*/
private int _surrogate = -1;
/**
* Total read character count; used for error reporting purposes
*/
private int _charCount = 0;
/**
* Total read byte count; used for error reporting purposes
*/
private int _byteCount = 0;
/**
* Flag that is set when a pending decode error has been detected; needed
* to properly handle deferred reporting.
*/
private int _decodeErrorOffset;
/*
/**********************************************************************
/* Life-cycle
/**********************************************************************
*/
public UTF8Reader(IOContext ctxt, InputStream in, boolean autoClose,
byte[] buf, int ptr, int len)
{
super((in == null) ? buf : in);
_ioContext = ctxt;
_inputSource = in;
_inputBuffer = buf;
_inputPtr = ptr;
_inputEnd = ptr+len;
_autoClose = autoClose;
// Unmodifiable if there is no stream to actually read from
// (ideally caller should pass explicitly)
_inputBufferReadOnly = (in == null);
}
public UTF8Reader(IOContext ctxt, byte[] buf, int ptr, int len)
{
super(new Object());
_ioContext = ctxt;
_inputSource = null;
_inputBuffer = buf;
_inputPtr = ptr;
_inputEnd = ptr+len;
_autoClose = true;
// This is the case when we have a buffer of contents already read
_inputBufferReadOnly = true;
}
public UTF8Reader(IOContext ctxt, InputStream in, boolean autoClose)
{
super(in);
_ioContext = ctxt;
_inputSource = in;
_inputBuffer = ctxt.allocReadIOBuffer();
_inputPtr = 0;
_inputEnd = 0;
_autoClose = autoClose;
// Buffer allocated above, modifiable as needed
_inputBufferReadOnly = false;
}
/*
/**********************************************************************
/* Reader API
/**********************************************************************
*/
@Override
public void close() throws IOException
{
InputStream in = _inputSource;
if (in != null) {
_inputSource = null;
if (_autoClose) {
in.close();
}
}
freeBuffers();
}
private char[] _tmpBuffer = null;
/**
* Although this method is implemented by the base class, AND it should
* never be called by parser code, let's still implement it bit more
* efficiently just in case
*/
@Override
public int read() throws IOException
{
if (_tmpBuffer == null) {
_tmpBuffer = new char[1];
}
if (read(_tmpBuffer, 0, 1) < 1) {
return -1;
}
return _tmpBuffer[0];
}
@Override
public int read(char[] cbuf) throws IOException {
return read(cbuf, 0, cbuf.length);
}
@Override
public int read(final char[] cbuf, final int start, int len) throws IOException
{
// validate input parameters
Objects.requireNonNull(cbuf, "cbuf == null");
Objects.checkFromIndexSize(start, len, cbuf.length);
// Already EOF?
if (_inputBuffer == null) {
return -1;
} else if (len == 0) {
// if len=0, we don't need to return anything
return 0;
}
len += start;
int outPtr = start;
// Ok, first; do we have a surrogate from last round?
if (_surrogate >= 0) {
cbuf[outPtr++] = (char) _surrogate;
_surrogate = -1;
// No need to load more, already got one char
// 15-Sep-2022, tatu: But need to avoid having empty buffer
if (_inputPtr >= _inputEnd) {
_charCount += 1;
return 1;
}
// otherwise let things work the way they should
} else {
if (_decodeErrorOffset != 0) {
reportDeferredInvalid();
}
// To prevent unnecessary blocking (esp. with network streams),
// we'll only require decoding of a single char
int left = (_inputEnd - _inputPtr);
// So; only need to load more if we can't provide at least one more character.
// We need not do thorough check here, but let's check the common cases here:
// either completely empty buffer (left == 0), or one with less than max. byte
// count for a single char, and starting of a multi-byte encoding (this leaves
// possibility of a 2/3-byte char that is still fully accessible...
// but that can be checked by the load method)
if (left < 4) {
// Need to load more?
if (left < 1 || _inputBuffer[_inputPtr] < 0) {
if (!loadMore(left)) { // (legal) EOF?
return -1;
}
}
}
}
final byte[] buf = _inputBuffer;
int inPtr = _inputPtr;
final int inBufLen = _inputEnd;
main_loop:
while (outPtr < len) {
// At this point we have at least one byte available
int c = buf[inPtr++];
// Let's first do the quickie loop for common case; 7-bit ASCII
if (c >= 0) { // ASCII? can probably loop, then
cbuf[outPtr++] = (char) c; // ok since MSB is never on
// Ok, how many such chars could we safely process without overruns?
// (will combine 2 in-loop comparisons into just one)
int outMax = (len - outPtr); // max output
int inMax = (inBufLen - inPtr); // max input
int inEnd = inPtr + ((inMax < outMax) ? inMax : outMax);
ascii_loop:
while (true) {
if (inPtr >= inEnd) {
break main_loop;
}
c = buf[inPtr++];
if (c < 0) { // or multi-byte
break ascii_loop;
}
cbuf[outPtr++] = (char) c;
}
}
int needed;
// Ok; if we end here, we got multi-byte combination
if ((c & 0xE0) == 0xC0) { // 2 bytes (0x0080 - 0x07FF), from 110xxxxx
c = (c & 0x1F);
needed = 1;
} else if ((c & 0xF0) == 0xE0) { // 3 bytes (0x0800 - 0xFFFF), from 1110xxxx
c = (c & 0x0F);
needed = 2;
} else if ((c & 0xF8) == 0xF0) { // 4 bytes from 11110xxx (double-char w/ surrogates and all)
c = (c & 0x0F);
needed = 3;
} else {
reportInvalidInitial(c & 0xFF, outPtr-start);
// 25-Aug-2016, tatu: As per [dataformat-csv#132], only returns
// if we are ok to return already decoded content and defer error reporting
--inPtr;
break main_loop;
}
/* Do we have enough bytes? If not, let's just push back the
* byte and leave, since we have already gotten at least one
* char decoded. This way we will only block (with read from
* input stream) when absolutely necessary.
*/
if ((inBufLen - inPtr) < needed) {
--inPtr;
break main_loop;
}
int d = buf[inPtr];
if ((d & 0xC0) != 0x080) {
reportInvalidOther(d & 0xFF, outPtr-start, 2);
break main_loop;
}
++inPtr;
c = (c << 6) | (d & 0x3F);
if (needed > 1) { // needed == 1 means 2 bytes total
d = buf[inPtr]; // 3rd byte
if ((d & 0xC0) != 0x080) {
reportInvalidOther(d & 0xFF, outPtr-start, 3);
break main_loop;
}
++inPtr;
c = (c << 6) | (d & 0x3F);
if (needed > 2) { // 4 bytes? (need surrogates)
d = buf[inPtr];
if ((d & 0xC0) != 0x080) {
reportInvalidOther(d & 0xFF, outPtr-start, 4);
break main_loop;
}
++inPtr;
c = (c << 6) | (d & 0x3F);
/* Ugh. Need to mess with surrogates. Ok; let's inline them
* there, then, if there's room: if only room for one,
* need to save the surrogate for the rainy day...
*/
c -= 0x10000; // to normalize it starting with 0x0
cbuf[outPtr++] = (char) (0xD800 + (c >> 10));
// hmmh. can this ever be 0? (not legal, at least?)
c = (0xDC00 | (c & 0x03FF));
// Room for second part?
if (outPtr >= len) { // nope
_surrogate = c;
break main_loop;
}
// sure, let's fall back to normal processing:
}
// Otherwise, should we check that 3-byte chars are
// legal ones (should not expand to surrogates?
// For now, let's not...
/*
else {
if (c >= 0xD800 && c < 0xE000) {
reportInvalid(c, outPtr-start, "(a surrogate character) ");
}
}
*/
}
cbuf[outPtr++] = (char) c;
if (inPtr >= inBufLen) {
break main_loop;
}
}
_inputPtr = inPtr;
final int actualLen = outPtr - start;
_charCount += actualLen;
return actualLen;
}
/*
/**********************************************************************
/* Internal/package methods:
/**********************************************************************
*/
protected final InputStream getStream() { return _inputSource; }
/**
* Method for reading as many bytes from the underlying stream as possible
* (that fit in the buffer), to the beginning of the buffer.
*/
protected final int readBytes()
throws IOException
{
_inputPtr = 0;
_inputEnd = 0;
if (_inputSource != null) {
int count = _inputSource.read(_inputBuffer, 0, _inputBuffer.length);
if (count > 0) {
_inputEnd = count;
}
return count;
}
return -1;
}
/**
* Method for reading as many bytes from the underlying stream as possible
* (that fit in the buffer considering offset), to the specified offset.
*
* @return Number of bytes read, if any; -1 to indicate none available
* (that is, end of input)
*/
protected final int readBytesAt(int offset)
throws IOException
{
// shouldn't modify mBytePtr, assumed to be 'offset'
if (_inputSource != null) {
int count = _inputSource.read(_inputBuffer, offset, _inputBuffer.length - offset);
if (count > 0) {
_inputEnd += count;
}
return count;
}
return -1;
}
/**
* This method should be called along with (or instead of) normal
* close. After calling this method, no further reads should be tried.
* Method will try to recycle read buffers (if any).
*/
public final void freeBuffers()
{
if (_ioContext != null) {
byte[] buf = _inputBuffer;
if (buf != null) {
_inputBuffer = null;
_ioContext.releaseReadIOBuffer(buf);
}
}
}
/*
/**********************************************************************
/* Internal methods
/**********************************************************************
*/
/**
* @param available Number of "unused" bytes in the input buffer
*
* @return True, if enough bytes were read to allow decoding of at least
* one full character; false if EOF was encountered instead.
*/
private boolean loadMore(int available) throws IOException
{
_byteCount += (_inputEnd - available);
if (available > 0) {
// Should we move bytes to the beginning of buffer?
if (_inputPtr > 0) {
// Can only do so if buffer mutable
if (!_inputBufferReadOnly) {
for (int i = 0; i < available; ++i) {
_inputBuffer[i] = _inputBuffer[_inputPtr+i];
}
_inputPtr = 0;
_inputEnd = available;
}
}
} else {
// Ok; here we can actually reasonably expect an EOF, so let's do a separate read right away:
int count = readBytes();
if (count < 1) {
freeBuffers(); // to help GC?
if (count < 0) { // -1
return false;
}
// 0 count is no good; let's err out
reportStrangeStream();
}
}
// We now have at least one byte... and that allows us to
// calculate exactly how many bytes we need!
@SuppressWarnings("cast")
int c = (int) _inputBuffer[_inputPtr];
if (c >= 0) { // single byte (ascii) char... cool, can return
return true;
}
// Ok, a multi-byte char, let's check how many bytes we'll need:
int needed;
if ((c & 0xE0) == 0xC0) { // 2 bytes (0x0080 - 0x07FF)
needed = 2;
} else if ((c & 0xF0) == 0xE0) { // 3 bytes (0x0800 - 0xFFFF)
needed = 3;
} else if ((c & 0xF8) == 0xF0) {
// 4 bytes; double-char BS, with surrogates and all...
needed = 4;
} else {
// 25-Aug-2016, tatu: As per [dataformat-csv#132], let's not throw
// exception from here but let caller handle
return true;
}
// And then we'll just need to load up to that many bytes;
// if an EOF is hit, that'll be an error. But we need not do
// actual decoding here, just load enough bytes.
while ((_inputPtr + needed) > _inputEnd) {
int count = readBytesAt(_inputEnd);
if (count < 1) {
if (count < 0) { // -1, EOF... no good!
freeBuffers();
reportUnexpectedEOF(_inputEnd - _inputPtr, needed);
}
// 0 count is no good; let's err out
reportStrangeStream();
}
}
return true;
}
protected void reportBounds(char[] cbuf, int start, int len) throws IOException {
throw new ArrayIndexOutOfBoundsException("read(buf,"+start+","+len+"), cbuf["+cbuf.length+"]");
}
protected void reportStrangeStream() throws IOException {
throw new IOException("Strange I/O stream, returned 0 bytes on read");
}
protected void reportInvalidInitial(int mask, int outputDecoded) throws IOException
{
// 25-Aug-2016, tatu: As per [dataformat-csv#132] defer error reporting if
// (but only if) some content has been decoded successfully
if (_decodeErrorOffset == 0) {
if (outputDecoded > 0) {
_decodeErrorOffset = 1;
return;
}
}
// input (byte) ptr has been advanced by one, by now:
int bytePos = _byteCount + _inputPtr - 1;
int charPos = _charCount + outputDecoded + 1;
throw new CharConversionException(String.format(
"Invalid UTF-8 start byte 0x%s (at char #%d, byte #%d): check content encoding, does not look like UTF-8",
Integer.toHexString(mask), charPos, bytePos));
}
protected void reportInvalidOther(int mask, int outputDecoded, int errorPosition) throws IOException
{
// 25-Aug-2016, tatu: As per [dataformat-csv#132] defer error reporting if
// (but only if) some content has been decoded successfully
if (_decodeErrorOffset == 0) {
if (outputDecoded > 0) {
_decodeErrorOffset = errorPosition;
return;
}
}
int bytePos = _byteCount + _inputPtr - 1;
int charPos = _charCount + outputDecoded + 1;
throw new CharConversionException(String.format(
"Invalid UTF-8 middle byte 0x%s (at char #%d, byte #%d): check content encoding, does not look like UTF-8",
Integer.toHexString(mask), charPos, bytePos));
}
protected void reportDeferredInvalid() throws IOException
{
int ch = _inputBuffer[_inputPtr] & 0xFF;
if (_decodeErrorOffset == 1) {
reportInvalidInitial(ch, 0);
} else {
reportInvalidOther(ch, 0, _decodeErrorOffset);
}
}
protected void reportUnexpectedEOF(int gotBytes, int needed) throws IOException
{
int bytePos = _byteCount + gotBytes;
int charPos = _charCount;
throw new CharConversionException(String.format(
"Unexpected EOF in the middle of a multi-byte UTF-8 character: got %d, needed %d, at char #%d, byte #%d)",
gotBytes, needed, charPos, bytePos));
}
}
================================================
FILE: csv/src/main/java/tools/jackson/dataformat/csv/impl/UTF8Writer.java
================================================
package tools.jackson.dataformat.csv.impl;
import java.io.*;
import tools.jackson.core.io.IOContext;
/**
* Efficient UTF-8 backed writer.
*