Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
univocity-parsers-2.9.1/README.md 0000664 0000000 0000000 00000003057 14001205434 0016506 0 ustar 00root root 0000000 0000000  Welcome to univocity-parsers ============================ univocity-parsers is a collection of extremely fast and reliable parsers for Java. It provides a consistent interface for handling different file formats, and a solid framework for the development of new parsers. We have finally updated the tutorial, please go to our website: https://www.univocity.com/pages/parsers-tutorial **Bugs, contributions & support** If you find a bug, please report it on github or send us an email on parsers@univocity.com. We try out best to eliminate all bugs as soon as possible and you’ll rarely see a bug open for more than 24 hours after it’s reported. We do our best to answer all questions. Enhancements/suggestions are implemented on a best effort basis. Fell free to submit your contribution via pull requests. Any little bit is appreciated, from improvements on documentation to a full blown rewrite from scratch. For commercial support, customizations or anything in between, please contact support@univocity.com. **Thank you for using our parsers!** Please consider sponsoring our project or [](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=JKH3JNHLL4Y42&source=url) any amount via PayPal, or Bitcoin on the following address: * 3BcmUPTPfLDuYWWSBxGKkChkq5WMzC94J6 Thank you! The univocity team. univocity-parsers-2.9.1/images/ 0000775 0000000 0000000 00000000000 14001205434 0016467 5 ustar 00root root 0000000 0000000 univocity-parsers-2.9.1/images/uniVocity-parsers.png 0000664 0000000 0000000 00000234251 14001205434 0022652 0 ustar 00root root 0000000 0000000 PNG IHDR _g bKGD pHYs Зƾ tIME IDATxI$Ys{/ƌjfWUv =WDM$VB $J qAh'P i!A+A jADf5.v5;*3ropw{^37o2 l<=0.Kr!">?&C"{T3CP : T;eo{fg}pM$ c)_y;:N!ϓR¶ H96ϩPƮUֿ>}v`[E d;;P֯scy{sw{r R>X"d'=6CD7s[;^ٸߖlo!m;omwΉ\_ ""B]t]GJ# -iuA L{T(h~bJ%x/ ۂ(< E6BF쟬ϦmUA RN } )Y]6#'?b/-0 ,ԕSgm. H*::x@eD.j !ᳮywcOX4MѶG X{)VCJĔHIQVYrvNWwzTr֖V2~qQ T#&#HYB z fpjZ8?=뉻o 15xg)=*lk<^GwVtE"r/zöy_sFfs^ǭG 3PUf\ <*2 dU&9OSט CsT.YV2cmê*%.el#;z,7γ|< s2A}gKV2l >gZI[Dz Ҕ҇PmT;d 0.5WђPX#Б s5"жmRu F`sUbe+ dN2BG ,T<Ұ| qܓד/ GN m܇-}8ê>^+#), % 19@%+1 6 revam *l)ك\0s4'DRZTþf}eix?y=y} !w|< /zCDEH+җs?,CIJ\?7 r8K՜>/AъRDS.;3 p 'A.@d#0)<,raJm͐mx b 2u H
p {DP|H Q?> ^ |Պ2K;r&*%RZA&2qMS5bTԛNst6s9#K'bD Hl6 r2DQ;Fl Pl(-%%A3ǐ9s5ϣT
J4z``#:rfܺ~_繺{Aw?}-y 2:E#իW>~@a/]lc3." ͼȸB) OLF`%";Qb4g6rzr]ԒBϻ=b 2mY#HZ| !& ި@:;w^+Rm-W ϣ?-aiڍN'{)=:$Q7A=|y[ V䦈ތ7opx4gkI+ά!s;TPRḀۛQ*pW
Zz4!N jﲥ N*TaKP Hq0bk.A#1B0Lwswk3 &(%t"!y뤂륛f`˸2),}W~_zmHKUFNNyYbhYEQeybpyj0|ƃ_A!Dg:)]T(0ڠF+ cowK..b< SB _:G5ą?g!+<+Ae!6R&K<'2R3|7Ka3eD]%]9 !Fʐe_3Z0cH>q[)J%]YQd%J/%M `9LbI%xˁZhT%RK(1FGtXgh>oSzfůI^ !畃{)J"D!tU XrmKQ=~/bۀ w
.0`T#DDZ60 7hlj?(C `TpQM-.O)9MmݟYT0gd%Az ȼe+3 uinΊ.4;s h5V[
!N A {@link BooleanConversion} will be assigned to this field
* Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor}
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
* @see Conversion
* @see Conversions
* @see BeanProcessor
* @see BeanWriterProcessor
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface BooleanString {
/**
* A set of Strings that represent the boolean value {@code true} (e.g. "y", "yes", "1")
*
* @return Strings that represent {@code true}
*/
String[] trueStrings();
/**
* A set of Strings that represent the boolean value {@code false} (e.g. "n", "no", "0")
*
* @return Strings that represent {@code false}
*/
String[] falseStrings();
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/Convert.java 0000664 0000000 0000000 00000004122 14001205434 0030763 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2014 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import com.univocity.parsers.common.processor.*;
import com.univocity.parsers.conversions.*;
import java.lang.annotation.*;
/**
* Assigns a custom implementation of {@link Conversion} to be executed ({@link Conversion#execute(Object)})
* when writing to the field and reverted ({@link Conversion#revert(Object)}) when reading from the field.
*
* @see Conversion
* @see Conversions
* @see BeanProcessor
* @see BeanWriterProcessor
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
* @author Univocity Software Pty Ltd - parsers@univocity.com
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface Convert {
/**
* A user provided implementation of {@link Conversion} which will be instantiated using the arguments provided by {@link Convert#args()}
* @return custom class used to convert values
*/
@SuppressWarnings("rawtypes") Class conversionClass();
/**
* The arguments to use when invoking the constructor of the class given by {@link Convert#conversionClass()}.
* @return list of arguments create a new instance of the custom conversion class.
*/
String[] args() default {};
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/Copy.java 0000664 0000000 0000000 00000005675 14001205434 0030273 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2016 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import java.lang.annotation.*;
/**
* Allows copying values of meta-annotation properties into the properties of an annotation that composes it. For example,
* consider the {@code @MyReplacement} meta-annotation defined below as:
*
* Values parsed from the input will be matched against one or more properties of the enumeration type.
* By default, values read from the input will be matched against: Use the {@link #selectors()} option to choose which properties to match the parsed input against, and in what order. You will only need to
* explicitly add a {@link EnumSelector#CUSTOM_FIELD} or {@link EnumSelector#CUSTOM_METHOD} to the list of {@link #selectors()} if your {@link #customElement()} name
* could point to both an attribute and a method in your enumeration. This will assign an {@link EnumConversion} to this field. Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor}
*
* @see BeanProcessor
* @see BeanWriterProcessor
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface EnumOptions {
/**
* A list of properties of the enumeration type that will be matched against the parsed input to identify which enum element should be assigned to the annotated field.
* By default, values read from the input will be matched against: You will only need to explicitly add a {@link EnumSelector#CUSTOM_FIELD} or {@link EnumSelector#CUSTOM_METHOD} to the list of {@link #selectors()}
* if your {@link #customElement()} name could point to both an attribute and a method in your enumeration. Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor}
*
* @author Univocity Software Pty Ltd - dev@univocity.com
* @see FixedWidthFields
* @see FixedWidthParser
* @see FixedWidthWriter
* @see FixedWidthParserSettings
* @see FixedWidthWriterSettings
* @see BeanProcessor
* @see BeanWriterProcessor
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface FixedWidth {
/**
* Sets the length of the fixed-width field
*
* @return length of the fixed-width field
*/
int value() default -1;
/**
* Sets the alignment of the fixed-width field
*
* @return alignment of the fixed-width field
*/
FieldAlignment alignment() default FieldAlignment.LEFT;
/**
* Sets the padding character of the fixed-width field
*
* @return padding of the fixed-width field
*/
char padding() default ' ';
/**
* Configures whether to retain the padding character when parsing values for this field
*
* (defaults to {@code false})
*
* @return flag indicating the padding character should be kept in the parsed value
*/
boolean keepPadding() default false;
/**
* Defines the starting position of the fixed-width field
*
* @return Defines the starting position of the fixed-width field
*/
int from() default -1;
/**
* Defines the end position of the fixed-width field
*
* @return Defines the end position of the fixed-width field
*/
int to() default -1;
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/Format.java 0000664 0000000 0000000 00000006564 14001205434 0030607 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2014 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import com.univocity.parsers.common.processor.BeanProcessor;
import com.univocity.parsers.common.processor.BeanWriterProcessor;
import com.univocity.parsers.conversions.Conversion;
import com.univocity.parsers.conversions.Conversions;
import java.lang.annotation.*;
/**
* Indicates that a parsed value is formatted and must be parsed before being assigned.
* The {@link Conversion} type assigned to this field will depend on its type. Multiple format masks can be tried for a single value. When reading from this value (for writing to a given output), the first mask declared in {@link Format#formats()} will be used to produce its String representation. The {@link #options()} is an optional configuration, with properties and values separated by =.. Each property will be used configure the underlying formatter. For example,
* if the parsed value is a BigDecimal, and the format is '#0,00', the decimal separator must be set to ','. To specify this using the {@link #options()} annotation, use:
*
* Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor} With this annotation, you can configure the sequence of headers to use when reading/writing:
* This annotation has no effect if {@link CommonSettings#isAutoConfigurationEnabled()} evaluates to {@code false}.
* Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor}
*
* @see Conversion
* @see Conversions
* @see BeanProcessor
* @see BeanWriterProcessor
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface LowerCase {
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/Nested.java 0000664 0000000 0000000 00000004562 14001205434 0030575 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2017 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import java.lang.annotation.*;
/**
* Marks a field as a nested object to be constructed with the values of the current row. It is expected that
* the annotated attribute is of a type, or provides an explicit type via the {@link #type()} option,
* that contains one or more {@link Parsed} annotations. The given type and its {@link Parsed} annotations will
* determine which fields from each row should be used to populate the {@code Nested} instance.
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface Nested {
/**
* Defines the concrete type of nested object to be instantiated, if it has to be a subclass of the declared attribute type.
*
* @return the type of nested object to be instantiated.
*/
Class type() default Object.class;
/**
* Provides a {@link HeaderTransformer} for reassigning header names/positions of the nested class.
*
* @return a transformation to be applied over headers/positions of the nested class.
* Used for reassigning specific input columns so the correct values end up in the correct nested attributes.
*/
Class headerTransformer() default HeaderTransformer.class;
/**
* An optional sequence of arguments for creating an instance of the given {@link #headerTransformer()}.
*
* @return the initialization arguments passed into the constructore of the {@link HeaderTransformer}
*/
String[] args() default {};
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/NullString.java 0000664 0000000 0000000 00000003460 14001205434 0031450 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2014 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import com.univocity.parsers.common.processor.*;
import com.univocity.parsers.conversions.*;
import java.lang.annotation.*;
/**
* Indicates that parsed values such as "", "?" or "null" should be interpreted as null. If a parsed value exists in {@link NullString#nulls()}, then the field must be set to null.
* A {@link NullStringConversion} will be assigned to this field
* Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor}
*
* @see Conversion
* @see Conversions
* @see BeanProcessor
* @see BeanWriterProcessor
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface NullString {
/**
* A set of Strings that represent a null value instead of a valid String (e.g. "?", "empty", "null" )
* @return Strings that represent {@code null}
*/
String[] nulls();
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/Parsed.java 0000664 0000000 0000000 00000011456 14001205434 0030571 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2014 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import com.univocity.parsers.annotations.helpers.*;
import com.univocity.parsers.common.*;
import com.univocity.parsers.common.processor.*;
import com.univocity.parsers.conversions.*;
import java.lang.annotation.*;
/**
* Indicates the field is parsed. If the annotated field type is not a String, it will be automatically converted using one
* of the existing {@link Conversion} implementations in package {@link com.univocity.parsers.conversions}.
*
*
* Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor}
* Implementation note: All annotations in @Parsed fields are processed by {@link AnnotationHelper}
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
* @see Conversion
* @see Conversions
* @see BeanProcessor
* @see BeanWriterProcessor
* @see AnnotationHelper
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface Parsed {
/**
* The possible field names of a record. If multiple names are provided, the parser/writer will
* attempt to match the given names against the headers provided (i.e. headers found in the input when parsing with
* {@link CommonParserSettings#isHeaderExtractionEnabled()}, or manually set using
* {@link com.univocity.parsers.common.CommonSettings#setHeaders(String...)} for writing or parsing)
*
* @return the possible field names (optional if the index is provided)
*/
String[] field() default {};
/**
* Field position in a parsed record
*
* @return the position of this field (optional if the field name is provided)
*/
int index() default -1;
/**
* The default value to assign to this field in the parsed value is null
* The String literal "null" will be interpreted as a regular null.
* Use "'null"' if you want the default value to be the string "null"
*
* this value will have different effects depending on the field type:
* The String literal "null" will be interpreted as a regular {@code null}.
* Use "'null"' if you want the default value to be the string {@code "null"}
*
* @return default String to write when the input is null.
*/
String defaultNullWrite() default "null";
/**
* Flag to indicate whether the parsed field should be converted automatically based on the field type. For example,
* if the annotated field is a {@code BigDecimal}, then {@link BigDecimalConversion} will be used to convert Strings to BigDecimal when reading
* and BigDecimal to String when writing. You may want to disable the default field conversion when using custom conversions through
* {@link BeanWriterProcessor#convertFields(Conversion...)},{@link BeanWriterProcessor#convertIndexes(Conversion...)} or
* {@link BeanWriterProcessor#convertAll(Conversion...)}.
*
* @return flag indicating whether the default conversion, based on the field type, is to be applied for this field.
*/
boolean applyDefaultConversion() default true;
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/Replace.java 0000664 0000000 0000000 00000003472 14001205434 0030725 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2014 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import com.univocity.parsers.common.processor.*;
import com.univocity.parsers.conversions.*;
import java.lang.annotation.*;
/**
* Indicates the String value of a field must have some of its contents replaced using {@link RegexConversion}.
*
* Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor}
*
* @see Conversion
* @see Conversions
* @see BeanProcessor
* @see BeanWriterProcessor
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface Replace {
/**
* The regular expression to be executed against the String value of the annotated field
* @return the regular expression
*/
String expression();
/**
* The replacement string to substitute any contents matched by the given {@link Replace#expression()}
* @return the replacement string
*/
String replacement();
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/Trim.java 0000664 0000000 0000000 00000002757 14001205434 0030272 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2014 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import com.univocity.parsers.common.processor.*;
import com.univocity.parsers.conversions.*;
import java.lang.annotation.*;
/**
* Indicates the String value of a field must be trimmed using {@link TrimConversion}.
*
* Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor}
*
* @see Conversion
* @see Conversions
* @see BeanProcessor
* @see BeanWriterProcessor
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface Trim {
int length() default -1;
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/UpperCase.java 0000664 0000000 0000000 00000002756 14001205434 0031245 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2014 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import com.univocity.parsers.common.processor.*;
import com.univocity.parsers.conversions.*;
import java.lang.annotation.*;
/**
* Indicates the String value of a field must be converted to uppercase using {@link UpperCaseConversion}.
*
* Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor}
*
* @see Conversion
* @see Conversions
* @see BeanProcessor
* @see BeanWriterProcessor
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface UpperCase {
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/Validate.java 0000664 0000000 0000000 00000005413 14001205434 0031100 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2018. Univocity Software Pty Ltd
* Commonly used for java beans processed using {@link BeanProcessor} and/or {@link BeanWriterProcessor}
*
* @see Conversion
* @see Conversions
* @see BeanProcessor
* @see BeanWriterProcessor
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface Validate {
/**
* Indicates whether this field can be {@code null}
* @return {@code true} true if nulls are allowed, {@code false} otherwise
*/
boolean nullable() default false;
/**
* Indicates whether this field can be blank (i.e. contain 0 or more whitespaces, where
* a whitespace is any character {@code <= ' '}
* @return {@code true} true if blanks are allowed, {@code false} otherwise
*/
boolean allowBlanks() default false;
/**
* Ensures that the value of this field matches a given regular expression.
* @return the regular expression that determines an expected format for the given value
*/
String matches() default "";
/**
* Ensures that the value of this field is one of a given set of alternatives
*
* @return the sequence of allowed values
*/
String[] oneOf() default {};
/**
* Ensures that the value of this field does is not an unwanted value.
*
* @return the sequence of disallowed values
*/
String[] noneOf() default {};
/**
* User provided implementations of {@link Validator} which will be executed
* in sequence after the validations specified in this annotation execute.
*
* @return custom classes to be used to validate any value associated with this field.
*/
Class[] validators() default {};
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/helpers/ 0000775 0000000 0000000 00000000000 14001205434 0030143 5 ustar 00root root 0000000 0000000 AnnotationHelper.java 0000664 0000000 0000000 00000134662 14001205434 0034215 0 ustar 00root root 0000000 0000000 univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/helpers /*******************************************************************************
* Copyright 2014 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations.helpers;
import com.univocity.parsers.annotations.*;
import com.univocity.parsers.annotations.Format;
import com.univocity.parsers.common.*;
import com.univocity.parsers.common.beans.*;
import com.univocity.parsers.common.input.*;
import com.univocity.parsers.conversions.*;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.math.*;
import java.text.*;
import java.util.*;
/**
* Helper class to process fields annotated with {@link Parsed}
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
*/
public class AnnotationHelper {
private static AnnotatedElement lastProcessedElement;
private static Class lastProcessedAnnotationType;
private static Annotation lastAnnotationFound;
private AnnotationHelper() {
}
/**
* Converts the special "null" strings that might be provided by {@link Parsed#defaultNullRead() and Parsed#defaultNullWrite()}
*
* @param defaultValue The string returned by {@link Parsed#defaultNullRead() and Parsed#defaultNullWrite()}
*
* @return the default value if it is not the String literal "null" or "'null'".
* If "null" was provided, then null will be returned.
* If "'null'" was provided, then "null" will be returned.
*/
private static String getNullValue(String defaultValue) {
if ("null".equals(defaultValue)) {
return null;
}
if ("'null'".equals(defaultValue)) {
return "null";
}
return defaultValue;
}
public static String getNullWriteValue(AnnotatedElement target, Parsed parsed) {
if (parsed == null) {
return null;
}
return getNullValue(AnnotationRegistry.getValue(target, parsed, "defaultNullWrite", parsed.defaultNullWrite()));
}
public static String getNullReadValue(AnnotatedElement target, Parsed parsed) {
if (parsed == null) {
return null;
}
return getNullValue(AnnotationRegistry.getValue(target, parsed, "defaultNullRead", parsed.defaultNullRead()));
}
/**
* Identifies the proper conversion for a given type and an annotation from the package {@link com.univocity.parsers.annotations}
*
* @param classType the type to have conversions applied to
* @param annotation the annotation from {@link com.univocity.parsers.annotations} that identifies a {@link Conversion} instance.
*
* @return The {@link Conversion} that should be applied to the type
*/
@SuppressWarnings("rawtypes")
public static Conversion getConversion(Class classType, Annotation annotation) {
return getConversion(classType, null, annotation, null, null);
}
public static EnumConversion createDefaultEnumConversion(Class fieldType, String nullRead, String nullWrite){
Enum nullReadValue = nullRead == null ? null : Enum.valueOf(fieldType, nullRead);
return new EnumConversion(fieldType, nullReadValue, nullWrite, null, EnumSelector.NAME, EnumSelector.ORDINAL, EnumSelector.STRING);
}
@SuppressWarnings({"rawtypes", "unchecked"})
public static Conversion getConversion(Class fieldType, AnnotatedElement target, Annotation annotation, String nullRead, String nullWrite) {
try {
Class annType = annotation.annotationType();
if (annType == NullString.class) {
NullString nullString = (NullString) annotation;
String[] nulls = AnnotationRegistry.getValue(target, nullString, "nulls", nullString.nulls());
return Conversions.toNull(nulls);
} else if (annType == Validate.class) {
Validate validate = (Validate) annotation;
boolean nullable = AnnotationRegistry.getValue(target, validate, "nullable", validate.nullable());
boolean allowBlanks = AnnotationRegistry.getValue(target, validate, "allowBlanks", validate.allowBlanks());
String[] oneOf = AnnotationRegistry.getValue(target, validate, "oneOf", validate.oneOf());
String[] noneOf = AnnotationRegistry.getValue(target, validate, "noneOf", validate.noneOf());
String matches = AnnotationRegistry.getValue(target, validate, "matches", validate.matches());
Class[] validators = AnnotationRegistry.getValue(target, validate, "validators", validate.validators());
return new ValidatedConversion(nullable, allowBlanks, oneOf, noneOf, matches, validators);
} else if (annType == EnumOptions.class) {
if (!fieldType.isEnum()) {
if (target == null) {
throw new IllegalStateException("Invalid " + EnumOptions.class.getName() + " instance for converting class " + fieldType.getName() + ". Not an enum type.");
} else {
throw new IllegalStateException("Invalid " + EnumOptions.class.getName() + " annotation on " + describeElement(target) + ". Attribute must be an enum type.");
}
}
EnumOptions enumOptions = ((EnumOptions) annotation);
String customElement = AnnotationRegistry.getValue(target, enumOptions, "customElement", enumOptions.customElement());
String element = customElement.trim();
if (element.isEmpty()) {
element = null;
}
Enum nullReadValue = nullRead == null ? null : Enum.valueOf(fieldType, nullRead);
EnumSelector[] selectors = AnnotationRegistry.getValue(target, enumOptions, "selectors", enumOptions.selectors());
return new EnumConversion(fieldType, nullReadValue, nullWrite, element, selectors);
} else if (annType == Trim.class) {
Trim trim = ((Trim) annotation);
int length = AnnotationRegistry.getValue(target, trim, "length", trim.length());
if (length == -1) {
return Conversions.trim();
} else {
return Conversions.trim(length);
}
} else if (annType == LowerCase.class) {
return Conversions.toLowerCase();
} else if (annType == UpperCase.class) {
return Conversions.toUpperCase();
} else if (annType == Replace.class) {
Replace replace = ((Replace) annotation);
String expression = AnnotationRegistry.getValue(target, replace, "expression", replace.expression());
String replacement = AnnotationRegistry.getValue(target, replace, "replacement", replace.replacement());
return Conversions.replace(expression, replacement);
} else if (annType == BooleanString.class) {
if (fieldType != boolean.class && fieldType != Boolean.class) {
if (target == null) {
throw new DataProcessingException("Invalid usage of " + BooleanString.class.getName() + ". Got type " + fieldType.getName() + " instead of boolean.");
} else {
throw new DataProcessingException("Invalid annotation: " + describeElement(target) + " has type " + fieldType.getName() + " instead of boolean.");
}
}
BooleanString boolString = ((BooleanString) annotation);
String[] falseStrings = AnnotationRegistry.getValue(target, boolString, "falseStrings", boolString.falseStrings());
String[] trueStrings = AnnotationRegistry.getValue(target, boolString, "trueStrings", boolString.trueStrings());
Boolean valueForNull = nullRead == null ? null : BooleanConversion.getBoolean(nullRead, trueStrings, falseStrings);
if (valueForNull == null && fieldType == boolean.class) {
valueForNull = Boolean.FALSE;
}
return Conversions.toBoolean(valueForNull, nullWrite, trueStrings, falseStrings);
} else if (annType == Format.class) {
Format format = ((Format) annotation);
String[] formats = AnnotationRegistry.getValue(target, format, "formats", format.formats());
String[] options = AnnotationRegistry.getValue(target, format, "options", format.options());
Locale locale = extractLocale(options);
TimeZone timezone = extractTimeZone(options);
Conversion conversion = null;
if (fieldType == BigDecimal.class) {
BigDecimal defaultForNull = nullRead == null ? null : new BigDecimal(nullRead);
conversion = Conversions.formatToBigDecimal(defaultForNull, nullWrite, formats);
} else if (Number.class.isAssignableFrom(fieldType) || (fieldType.isPrimitive()) && fieldType != boolean.class && fieldType != char.class) {
conversion = Conversions.formatToNumber(formats);
((NumericConversion) conversion).setNumberType(fieldType);
} else {
Date dateIfNull = null;
if (nullRead != null) {
if ("now".equalsIgnoreCase(nullRead)) {
dateIfNull = new Date();
} else {
if (formats.length == 0) {
throw new DataProcessingException("No format defined");
}
SimpleDateFormat sdf = new SimpleDateFormat(formats[0], locale);
sdf.setTimeZone(timezone);
dateIfNull = sdf.parse(nullRead);
}
}
if (Date.class == fieldType) {
conversion = Conversions.toDate(timezone, locale, dateIfNull, nullWrite, formats);
} else if (Calendar.class == fieldType) {
Calendar calendarIfNull = null;
if (dateIfNull != null) {
calendarIfNull = Calendar.getInstance();
calendarIfNull.setTime(dateIfNull);
calendarIfNull.setTimeZone(timezone);
}
conversion = Conversions.toCalendar(timezone, locale, calendarIfNull, nullWrite, formats);
}
}
if (conversion != null) {
if (options.length > 0) {
if (conversion instanceof FormattedConversion) {
Object[] formatters = ((FormattedConversion) conversion).getFormatterObjects();
for (Object formatter : formatters) {
applyFormatSettings(formatter, options);
}
} else {
throw new DataProcessingException("Options '" + Arrays.toString(options) + "' not supported by conversion of type '" + conversion.getClass() + "'. It must implement " + FormattedConversion.class);
}
}
return conversion;
}
} else if (annType == Convert.class) {
Convert convert = ((Convert) annotation);
String[] args = AnnotationRegistry.getValue(target, convert, "args", convert.args());
Class conversionClass = AnnotationRegistry.getValue(target, convert, "conversionClass", convert.conversionClass());
return (Conversion) newInstance(Conversion.class, conversionClass, args);
}
if (fieldType == String.class && (nullRead != null || nullWrite != null)) {
return new ToStringConversion(nullRead, nullWrite);
}
return null;
} catch (DataProcessingException ex) {
throw ex;
} catch (Throwable ex) {
if (target == null) {
throw new DataProcessingException("Unexpected error identifying conversions to apply over type " + fieldType, ex);
} else {
throw new DataProcessingException("Unexpected error identifying conversions to apply over " + describeElement(target), ex);
}
}
}
private static String extractOption(String[] options, String key) {
for (int i = 0; i < options.length; i++) {
if (options[i] != null && options[i].trim().toLowerCase().startsWith(key)) {
String out = options[i].split("=")[1].trim();
options[i] = null;
return out;
}
}
return null;
}
private static TimeZone extractTimeZone(String[] options) {
String code = extractOption(options, "timezone=");
if (code != null) {
return TimeZone.getTimeZone(code);
}
return TimeZone.getDefault();
}
private static Locale extractLocale(String[] options) {
String locale = extractOption(options, "locale=");
if (locale != null) {
String languageCode;
String countryCode;
String variant;
CharAppender appender = new DefaultCharAppender(100, "", 0);
int j = 0;
char ch;
for (; j < locale.length() && Character.isLetterOrDigit((ch = locale.charAt(j))); j++, appender.append(ch))
;
languageCode = appender.getAndReset();
for (++j; j < locale.length() && Character.isLetterOrDigit((ch = locale.charAt(j))); j++, appender.append(ch))
;
countryCode = appender.getAndReset();
for (++j; j < locale.length() && Character.isLetterOrDigit((ch = locale.charAt(j))); j++, appender.append(ch))
;
variant = appender.getAndReset();
return new Locale(languageCode, countryCode, variant);
}
return Locale.getDefault();
}
public static It handles all settings defined by {@link CommonParserSettings}, and delegates the parsing algorithm implementation to its subclasses through the
* abstract method {@link AbstractParser#parseRecord()}
* The following (absolutely required) attributes are exposed to subclasses:
* The AbstractParser handles the initialization and processing of the input until it is ready to be parsed.
* It then delegates the input to the parser-specific implementation defined by {@link #parseRecord()}. In general, an implementation of
* {@link AbstractParser#parseRecord()} will perform the following steps:
* Once the {@link #parseRecord()} returns, the AbstractParser takes over and handles the information (generally, reorganizing it and passing it on to a {@link RowProcessor}).
* After the record processing, the AbstractParser reads the next characters from the input, delegating control again to the parseRecord() implementation for processing of the next record.
* This cycle repeats until the reading process is stopped by the user, the input is exhausted, or an error happens.
* In case of errors, the unchecked exception {@link TextParsingException} will be thrown and all resources in use will be closed automatically
* unless {@link CommonParserSettings#isAutoClosingEnabled()} evaluates to {@code false}. The exception should contain the cause and more information about where in the input the error happened.
*
* @see com.univocity.parsers.common.input.CharInputReader
* @see com.univocity.parsers.common.input.CharAppender
* @see com.univocity.parsers.common.ParserOutput
* @see com.univocity.parsers.common.TextParsingException
* @see com.univocity.parsers.common.processor.RowProcessor
*/
protected abstract void parseRecord();
/**
* Allows the parser implementation to handle any value that was being consumed when the end of the input was reached
*
* @return a flag indicating whether the parser was processing a value when the end of the input was reached.
*/
protected boolean consumeValueOnEOF() {
return false;
}
private String[] handleEOF() {
String[] row = null;
try {
boolean consumeValueOnEOF = consumeValueOnEOF();
if (output.column != 0 || (consumeValueOnEOF && !context.isStopped())) {
if (output.appender.length() > 0 || consumeValueOnEOF) {
output.valueParsed();
} else if (input.currentParsedContentLength() > 0) {
output.emptyParsed();
}
row = output.rowParsed();
} else if (output.appender.length() > 0 || input.currentParsedContentLength() > 0) {
if (output.appender.length() == 0) {
output.emptyParsed();
} else {
output.valueParsed();
}
row = output.rowParsed();
} else if (!output.pendingRecords.isEmpty()) {
row = output.pendingRecords.poll();
}
} catch (Throwable e) {
throw handleException(e);
}
if (row != null && processor != NoopProcessor.instance) {
rowProcessed(row);
}
return row;
}
/**
* Starts an iterator-style parsing cycle. If a {@link RowProcessor} is provided in the configuration, it will be used to perform additional processing.
* The parsed records must be read one by one with the invocation of {@link AbstractParser#parseNext()}.
* The user may invoke @link {@link AbstractParser#stopParsing()} to stop reading from the input.
*
* @param reader The input to be parsed.
*/
public final void beginParsing(Reader reader) {
output.reset();
if (reader instanceof LineReader) {
input = new DefaultCharInputReader(settings.getFormat().getLineSeparator(), settings.getFormat().getNormalizedNewline(), settings.getInputBufferSize(), whitespaceRangeStart, true);
} else {
input = settings.newCharInputReader(whitespaceRangeStart);
}
input.enableNormalizeLineEndings(true);
context = createParsingContext();
if (processor instanceof DefaultConversionProcessor) {
DefaultConversionProcessor conversionProcessor = ((DefaultConversionProcessor) processor);
conversionProcessor.errorHandler = errorHandler;
conversionProcessor.context = context;
}
if (input instanceof AbstractCharInputReader) {
AbstractCharInputReader inputReader = ((AbstractCharInputReader) input);
inputReader.addInputAnalysisProcess(getInputAnalysisProcess());
for(InputAnalysisProcess p : settings.getInputAnalysisProcesses()){
inputReader.addInputAnalysisProcess(p);
}
}
try {
input.start(reader);
} catch (Throwable t) {
throw handleException(t);
}
input.skipLines(rowsToSkip);
initialize();
processor.processStarted(context);
}
void extractHeadersIfRequired() {
while (extractHeaders && output.parsedHeaders == null && !context.isStopped() && !extractingHeaders) {
Processor userProvidedProcessor = processor;
try {
processor = NoopProcessor.instance; //disables any users provided processors to capture headers
extractingHeaders = true;
parseNext();
} finally {
extractingHeaders = false;
processor = userProvidedProcessor;
}
}
}
protected ParsingContext createParsingContext() {
DefaultParsingContext out = new DefaultParsingContext(this, errorContentLength);
out.stopped = false;
return out;
}
protected void initialize() {
}
/**
* Allows the parser implementation to traverse the input buffer before the parsing process starts, in order to enable automatic configuration and discovery
* of data formats.
*
* @return a custom implementation of {@link InputAnalysisProcess}. By default, {@code null} is returned and no special input analysis will be performed.
*/
protected InputAnalysisProcess getInputAnalysisProcess() {
return null;
}
private String getParsedContent(CharSequence tmp) {
return "Parsed content: " + AbstractException.restrictContent(errorContentLength, tmp);
}
private TextParsingException handleException(Throwable ex) {
if (context != null) {
context.stop();
}
if (ex instanceof DataProcessingException) {
DataProcessingException error = (DataProcessingException) ex;
error.restrictContent(errorContentLength);
error.setContext(this.context);
throw error;
}
String message = ex.getClass().getName() + " - " + ex.getMessage();
char[] chars = output.appender.getChars();
if (chars != null) {
int length = output.appender.length();
if (length > chars.length) {
message = "Length of parsed input (" + length + ") exceeds the maximum number of characters defined in" +
" your parser settings (" + settings.getMaxCharsPerColumn() + "). ";
length = chars.length;
}
String tmp = new String(chars);
if (tmp.contains("\n") || tmp.contains("\r")) {
tmp = displayLineSeparators(tmp, true);
String lineSeparator = displayLineSeparators(settings.getFormat().getLineSeparatorString(), false);
message += "\nIdentified line separator characters in the parsed content. This may be the cause of the error. " +
"The line separator in your parser settings is set to '" + lineSeparator + "'. " + getParsedContent(tmp);
}
int nullCharacterCount = 0;
//ensuring the StringBuilder won't grow over Integer.MAX_VALUE to avoid OutOfMemoryError
int maxLength = length > Integer.MAX_VALUE / 2 ? Integer.MAX_VALUE / 2 - 1 : length;
StringBuilder s = new StringBuilder(maxLength);
for (int i = 0; i < maxLength; i++) {
if (chars[i] == '\0') {
s.append('\\');
s.append('0');
nullCharacterCount++;
} else {
s.append(chars[i]);
}
}
tmp = s.toString();
if (nullCharacterCount > 0) {
message += "\nIdentified " + nullCharacterCount + " null characters ('\0') on parsed content. This may " +
"indicate the data is corrupt or its encoding is invalid. Parsed content:\n\t" + getParsedContent(tmp);
}
}
if (ex instanceof ArrayIndexOutOfBoundsException) {
try {
int index = Integer.parseInt(ex.getMessage());
if (index == settings.getMaxCharsPerColumn()) {
message += "\nHint: Number of characters processed may have exceeded limit of " + index + " characters per column. Use settings.setMaxCharsPerColumn(int) to define the maximum number of characters a column can have";
}
if (index == settings.getMaxColumns()) {
message += "\nHint: Number of columns processed may have exceeded limit of " + index + " columns. Use settings.setMaxColumns(int) to define the maximum number of columns your input can have";
}
message += "\nEnsure your configuration is correct, with delimiters, quotes and escape sequences that match the input format you are trying to parse";
} catch (Throwable t) {
//ignore;
}
}
try {
if (!message.isEmpty()) {
message += "\n";
}
message += "Parser Configuration: " + settings.toString();
} catch (Exception t) {
//ignore
}
if (errorContentLength == 0) {
output.appender.reset();
}
TextParsingException out = new TextParsingException(context, message, ex);
out.setErrorContentLength(errorContentLength);
return out;
}
/**
* In case of errors, stops parsing and closes all open resources. Avoids hiding the original exception in case another error occurs when stopping.
*/
private void stopParsing(Throwable error) {
if (error != null) {
try {
stopParsing();
} catch (Throwable ex) {
// ignore and throw original error.
}
if (error instanceof DataProcessingException) {
DataProcessingException ex = (DataProcessingException) error;
ex.setContext(context);
throw ex;
} else if (error instanceof RuntimeException) {
throw (RuntimeException) error;
} else if (error instanceof Error) {
throw (Error) error;
} else {
throw new IllegalStateException(error.getMessage(), error);
}
} else {
stopParsing();
}
}
/**
* Stops parsing and closes all open resources.
*/
public final void stopParsing() {
try {
ch = '\0';
try {
if (context != null) {
context.stop();
}
} finally {
try {
if (processor != null) {
processor.processEnded(context);
}
} finally {
if (output != null) {
output.appender.reset();
}
if (input != null) {
input.stop();
}
}
}
} catch (Throwable error) {
throw handleException(error);
}
}
private M@ĶQW.Mgs.>Ja%cB`v3)ytaŪ9]G=0?7Ke áF"DJFNڭ`Hi4Z4D`
C^
9 AGP 3_(>[Um!C"e49K9~ !QFt
Q
ygtC<IvO K/W_zAnZ EIHO\I31Eٖ@ЖȐެep, K? Ǐ Ɲe6GrƂg
-VrBR jcˮj$ECm@}>%FX۠U>}^Uq =xu~ӯrmV؍"݈K0 ăxxxAHmמz4#6Ibt#SA)lAaDGdgajV 9Δتf %~AU)V)b$"b
zNT " 1TH* CjrwdPWv
tkz }5Aua $? }/cQ<N}< #w?LՃ( Ōr3 =zof<ƫd>
g^{Ϟckmo}pOmEFд@$%X-
,p)c~Dr.,蠁 #E
@"Fe]_+7XJ]7] r?K_ؑz/3#Mw:6F _F[
()E VJJ)snyih|C=G rf7rnXR;\Qb0KG2Te@/RDi b=b"t|`(A*R*Z!ZJ;L +tz{OKeU S{FO3j'J c}>jw }x$xa
*
*
* Values set on attributes {@code field} or {@code myIndex} in {@code @MyReplacement} will be assigned to the
* attributes {@code field} and {@code index} of the {@code @Parsed} annotation. This allows you to apply the
* {@code @MyReplacement} annotation to any given field of your class while configuring the field name and index
* to be set for the {@code @Parsed} annotation. This eliminates the need for adding explicit, additional annotations and
* their specific property values to each and every field.
*
* The following class can now make use of the {@code @MyReplacement} annotation to apply the the annotations
* {@code @Replace} and {@code @Parsed}, configuring the properties of the "inherited" {@code @Parsed}:
*
*
*
* {@literal @}Replace(expression = "`", replacement = "")
* {@literal @}Parsed
* public {@literal @}interface MyReplacement {
*
* {@literal @}Copy(to = Parsed.class)
* String field() default "";
*
* {@literal @}Copy(to = Parsed.class, property = "index")
* int myIndex() default -1;
* }
*
*
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target(ElementType.METHOD)
public @interface Copy {
/**
* Target annotation class that is part of a meta-annotation.
*
* @return the class whose properties will be set from a given attribute of a meta-annotation
*/
Class to();
/**
* Target property of the given annotation class that is part of a meta-annotation.
*
* @return the name of the property in the given annotation class that should receive the value of the
* meta-annotation property.
*/
String property() default "";
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/EnumOptions.java 0000664 0000000 0000000 00000010125 14001205434 0031623 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2015 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import com.univocity.parsers.common.processor.*;
import com.univocity.parsers.conversions.*;
import java.lang.annotation.*;
/**
* The {@code EnumSelector} annotation is meant to be used in conjunction with enumeration attributes.
*
*
* public class MyBean {
*
* {@literal @}MyReplacement
* public String id;
*
* {@literal @}MyReplacementUpperCase(field = "client_name")
* public String name;
*
* {@literal @}MyReplacementUpperCase(myIndex = 4)
* public String address;
* }
*
*
*
*
* You can also define a {@link #customElement()} of your enumeration type (an attribute or method), as long as it
* uniquely identifies each value of your enumeration type.
*
*
*
* @return the sequence of properties of the enumeration type to match against the parsed input.
*/
EnumSelector[] selectors() default {EnumSelector.NAME, EnumSelector.ORDINAL, EnumSelector.STRING};
/**
*
* Defines the name of a custom element (attribute or method) of the annotated enumeration. This will be used to match the parsed input and identify an individual value of the enumeration.
* The attribute value, or object returned from the method, should uniquely identify a value of the enumeration;
*
*
*
*
* public class Wheel {
* @Parsed
* String brand;
*
* @Parsed
* int miles;
* }
*
*
* And a {@code Car} which has four {@code Wheels}:
*
*
* public static class Car {
* @Nested
* Wheel frontLeft;
*
* @Nested
* Wheel frontRight;
*
* @Nested
* Wheel rearLeft;
*
* @Nested
* Wheel rearRight;
* }
*
*
* The {@code HeaderTransformer} allows us to "rename" the attributes of each different {@code Wheel} of the {@code Car}
* so that input columns can be assigned to the appropriate places.
*
* Assuming an input with headers {@code frontLeftWheelBrand,frontLeftWheelMiles,frontRightWheelBrand,frontRightWheelMiles,rearLeftWheelBrand,rearLeftWheelMiles,rearRightWheelBrand,rearRightWheelMiles},
* a {@code HeaderTransformer} can be created like this to assign a prefix in front of the header names derived from {@code Wheel} (originally just "brand" and "miles"):
*
*
* public static class PrefixTransformer extends HeaderTransformer {
*
* private String prefix;
*
* public PrefixTransformer(String... args) {
* prefix = args[0];
* }
*
* @Override
* public String transformName(Field field, String name) {
* return prefix + Character.toUpperCase(name.charAt(0)) + name.substring(1);
* }
* }
*
*
* This allows us to to define the {@code Car} class as:
*
*
* public static class Car {
* @Nested(headerTransformer = PrefixTransformer.class, args = "frontLeftWheel")
* Wheel frontLeft;
*
* @Nested(headerTransformer = PrefixTransformer.class, args = "frontRightWheel")
* Wheel frontRight;
*
* @Nested(headerTransformer = PrefixTransformer.class, args = "rearLeftWheel")
* Wheel rearLeft;
*
* @Nested(headerTransformer = PrefixTransformer.class, args = "rearRightWheel")
* Wheel rearRight;
* }
*
*
* The above annotation will prefix the {@code frontLeft} fields ("brand" and "miles") with "frontLeftWheel", effectively
* forming the header "frontLeftWheelBrand" and "frontLeftWheelMiles", which will match the input headers and assign the
* correct values to the correct {@code Wheel} instance.
*
* IMPORTANT It is mandatory to define a constructor that takes {@code String[]} as a parameter. The actual
* parameter values come from {@link Nested#args()} to allow custom configuration of the concrete {@code HeaderTransformer} instance.
*
* @author Univocity Software Pty Ltd - dev@univocity.com
*/
public abstract class HeaderTransformer {
public final String transformName(AnnotatedElement element, String name) {
if (element instanceof Field) {
return transformName((Field) element, name);
} else {
return transformName((Method) element, name);
}
}
public final int transformIndex(AnnotatedElement element, int index) {
if (element instanceof Field) {
return transformIndex((Field) element, index);
} else {
return transformIndex((Method) element, index);
}
}
/**
* Transforms a header name
*
* @param field the field of a {@link Nested} class whose header will be transformed
* @param name the current header name associated with the field of the {@link Nested} class
*
* @return the transformed header name to be used to read/write values from/to the given field.
*/
public String transformName(Field field, String name) {
return name;
}
/**
* Transforms a header index
*
* @param field the field of a {@link Nested} class whose header will be transformed
* @param index the current column position associated with the field of the {@link Nested} class
*
* @return the transformed position to be used to read/write values from/to the given field.
*/
public int transformIndex(Field field, int index) {
return index;
}
/**
* Transforms a header name
*
* @param method the method of a {@link Nested} class whose header will be transformed
* @param name the current header name associated with the method of the {@link Nested} class
*
* @return the transformed header name to be used to read/write values from/to the given method.
*/
public String transformName(Method method, String name) {
return name;
}
/**
* Transforms a header index
*
* @param method the method of a {@link Nested} class whose header will be transformed
* @param index the current column position associated with the method of the {@link Nested} class
*
* @return the transformed position to be used to read/write values from/to the given method.
*/
public int transformIndex(Method method, int index) {
return index;
}
}
univocity-parsers-2.9.1/src/main/java/com/univocity/parsers/annotations/Headers.java 0000664 0000000 0000000 00000005740 14001205434 0030725 0 ustar 00root root 0000000 0000000 /*******************************************************************************
* Copyright 2015 Univocity Software Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.univocity.parsers.annotations;
import com.univocity.parsers.common.*;
import com.univocity.parsers.common.processor.*;
import java.lang.annotation.*;
/**
* The {@code Headers} annotation allows java beans to configure how to handle field names in a given input/output
*
*
*
*
*
*
*
*
* @return the default String to return when the parsed value is null
*/
String defaultNullRead() default "null";
/**
* The default value to read from this field if it is null. Used for writing to an output by {@link BeanWriterProcessor}.
*
*
*
* @param
*
*
*
*
* @param The specific writer settings configuration class, which can potentially provide additional configuration options supported by the writer
* implementation.
*
* @author Univocity Software Pty Ltd - parsers@univocity.com
* @see com.univocity.parsers.csv.CsvWriter
* @see com.univocity.parsers.csv.CsvWriterSettings
* @see com.univocity.parsers.fixed.FixedWidthWriter
* @see com.univocity.parsers.fixed.FixedWidthWriterSettings
* @see com.univocity.parsers.tsv.TsvWriter
* @see com.univocity.parsers.tsv.TsvWriterSettings
* @see com.univocity.parsers.common.input.WriterCharAppender
* @see com.univocity.parsers.common.processor.RowWriterProcessor
*/
public abstract class AbstractWriter> {
@SuppressWarnings("rawtypes")
private final RowWriterProcessor writerProcessor;
private Writer writer;
private final boolean skipEmptyLines;
protected final char comment;
private final WriterCharAppender rowAppender;
private final boolean isHeaderWritingEnabled;
private Object[] outputRow;
private int[] indexesToWrite;
private final char[] lineSeparator;
protected NormalizedString[] headers;
protected long recordCount = 0;
protected final String nullValue;
protected final String emptyValue;
protected final WriterCharAppender appender;
private final Object[] partialLine;
private int partialLineIndex = 0;
private Map
*
* Once the {@link #processRow(Object[])} method returns, a row will be written to the output with the processed information, and a newline will be automatically written after the given contents, unless this is a
* {@link com.univocity.parsers.fixed.FixedWidthWriter} whose {@link FixedWidthWriterSettings#getWriteLineSeparatorAfterRecord()} evaluates to {@code false}. The newline character sequence will conform to what is specified in {@link Format#getLineSeparator()}
* This cycle repeats until the writing process is stopped by the user or an error happens.
* In case of errors, the unchecked exception {@link TextWritingException} will be thrown and all resources in use will be closed automatically. The exception should contain the cause and more information about the output state when the error happened.
*
* @param row the data to be written to the output in the expected format.
*
* @see com.univocity.parsers.common.input.CharAppender
* @see com.univocity.parsers.common.CommonWriterSettings
*/
protected abstract void processRow(Object[] row);
/**
* Appends the processed sequence of characters in {@link AbstractWriter#appender} to the output row.
*/
protected final void appendValueToRow() {
rowAppender.append(appender);
}
/**
* Appends the given character to the output row.
*
* @param ch the character to append to the output row
*/
protected final void appendToRow(char ch) {
rowAppender.append(ch);
}
/**
* Appends the given character sequence to the output row
*
* @param chars the sequence of characters to append to the output row
*/
protected final void appendToRow(char[] chars) {
rowAppender.append(chars);
}
/**
* Writes the headers defined in {@link CommonSettings#getHeaders()}
* A {@link TextWritingException} will be thrown if no headers were defined or if records were already written to the output.
*/
public final void writeHeaders() {
writeHeaders(NormalizedString.toArray(this.headers));
}
/**
* Writes the given collection of headers to the output.
* A {@link TextWritingException} will be thrown if no headers were defined or if records were already written to the output.
*
* @param headers the headers to write to the output.
*/
public final void writeHeaders(Collection headers) {
if (headers != null && headers.size() > 0) {
writeHeaders(headers.toArray(new String[headers.size()]));
} else {
throw throwExceptionAndClose("No headers defined.");
}
}
/**
* Writes the given collection of headers to the output.
* A {@link TextWritingException} will be thrown if no headers were defined or if records were already written to the output.
*
* @param headers the headers to write to the output.
*/
public final void writeHeaders(String... headers) {
if (recordCount > 0) {
throw throwExceptionAndClose("Cannot write headers after records have been written.", headers, null);
}
if (headers != null && headers.length > 0) {
writingHeaders = true;
if (columnReorderingEnabled && outputRow != null) {
fillOutputRow(headers);
headers = Arrays.copyOf(outputRow, outputRow.length, String[].class);
}
this.headers = NormalizedString.toIdentifierGroupArray(headers);
submitRow(headers);
internalWriteRow();
writingHeaders = false;
} else {
throw throwExceptionAndClose("No headers defined.", headers, null);
}
}
/**
* Iterates over all records, processes each one with the {@link RowWriterProcessor} provided by {@link CommonWriterSettings#getRowWriterProcessor()}, and
* writes them, then finally and closes the output
* A {@link TextWritingException} will be thrown if no {@link RowWriterProcessor} is provided by {@link CommonWriterSettings#getRowWriterProcessor()}.
*
* @param allRecords the records to be transformed by a {@link RowWriterProcessor} and then written to the output
*/
public final void processRecordsAndClose(Iterable allRecords) {
try {
processRecords(allRecords);
} finally {
close();
}
}
/**
* Iterates over all records, processes each one with the {@link RowWriterProcessor} provided by {@link CommonWriterSettings#getRowWriterProcessor()}, and
* writes them, then finally and closes the output
* A {@link TextWritingException} will be thrown if no {@link RowWriterProcessor} is provided by {@link CommonWriterSettings#getRowWriterProcessor()}.
*
* @param allRecords the records to be transformed by a {@link RowWriterProcessor} and then written to the output
*/
public final void processRecordsAndClose(Object[] allRecords) {
try {
processRecords(allRecords);
} finally {
close();
}
}
/**
* Iterates over all records, processes each one with the {@link RowWriterProcessor} provided by {@link CommonWriterSettings#getRowWriterProcessor()}, and
* writes them.
* The output will remain open for further writing.
* A {@link TextWritingException} will be thrown if no {@link RowWriterProcessor} is provided by {@link CommonWriterSettings#getRowWriterProcessor()}.
*
* @param records the records to be transformed by a {@link RowWriterProcessor} and then written to the output
*/
public final void processRecords(Iterable records) {
for (Object record : records) {
processRecord(record);
}
}
/**
* Iterates over all records, processes each one with the {@link RowWriterProcessor} provided by {@link CommonWriterSettings#getRowWriterProcessor()}, and
* writes them.
* The output will remain open for further writing.
* * A {@link TextWritingException} will be thrown if no {@link RowWriterProcessor} is provided by {@link CommonWriterSettings#getRowWriterProcessor()}.
*
* @param records the records to transformed by a {@link RowWriterProcessor} and then written to the output
*/
public final void processRecords(Object[] records) {
for (Object record : records) {
processRecord(record);
}
}
/**
* Iterates over all records, processes each one with the {@link RowWriterProcessor} provided by {@link CommonWriterSettings#getRowWriterProcessor()}, and
* writes them.
* The output will remain open for further writing.
* * A {@link TextWritingException} will be thrown if no {@link RowWriterProcessor} is provided by {@link CommonWriterSettings#getRowWriterProcessor()}.
*
* @param records the records to transformed by a {@link RowWriterProcessor} and then written to the output
* @param
*
*
* @param element the object to be converted into a String.
*
* @return the String representation of the given object
*/
protected String getStringValue(Object element) {
usingNullOrEmptyValue = false;
if (element == null) {
usingNullOrEmptyValue = true;
return nullValue;
}
String string = String.valueOf(element);
if (string.isEmpty()) {
usingNullOrEmptyValue = true;
return emptyValue;
}
if (this.ignoreLeading) {
int start = skipLeadingWhitespace(whitespaceRangeStart, string);
if (start == string.length()) {
usingNullOrEmptyValue = true;
return emptyValue;
}
}
return string;
}
/**
* Writes a sequence of values to a row in memory. Subsequent calls to this method will add the given values in a new column of the same row, until {@link
* #writeValuesToRow} is called to flush
* all values accumulated and effectively write a new record to the output
*
* @param values the values to be written
*/
public final void addValues(Object... values) {
try {
System.arraycopy(values, 0, partialLine, partialLineIndex, values.length);
partialLineIndex += values.length;
} catch (Throwable t) {
throw throwExceptionAndClose("Error adding values to in-memory row", values, t);
}
}
/**
* Writes a sequence of Strings to a row in memory. Subsequent calls to this method will add the given values in a new column of the same row, until {@link
* #writeValuesToRow} is called to flush
* all values accumulated and effectively write a new record to the output
*
* @param values the values to be written
*/
public final void addStringValues(Collection