@Override
public void initAnnotatedFields() {
maxpos = 0;
for (Class<?> cl : models) {
List<Field> linkFields = new ArrayList<Field>();
if (LOG.isDebugEnabled()) {
LOG.debug("Class retrieved: {}", cl.getName());
}
for (Field field : cl.getDeclaredFields()) {
DataField dataField = field.getAnnotation(DataField.class);
if (dataField != null) {
if (LOG.isDebugEnabled()) {
LOG.debug(
"Position defined in the class: {}, position: {}, Field: {}",
new Object[] {cl.getName(), dataField.pos(), dataField});
}
if (dataField.required()) {
++numberMandatoryFields;
} else {
++numberOptionalFields;
}
int pos = dataField.pos();
if (annotatedFields.containsKey(pos)) {
Field f = annotatedFields.get(pos);
LOG.warn(
"Potentially invalid model: existing @DataField '{}' replaced by '{}'",
f.getName(),
field.getName());
}
dataFields.put(pos, dataField);
annotatedFields.put(pos, field);
maxpos = Math.max(maxpos, pos);
}
Link linkField = field.getAnnotation(Link.class);
if (linkField != null) {
if (LOG.isDebugEnabled()) {
LOG.debug("Class linked: {}, Field: {}", cl.getName(), field);
}
linkFields.add(field);
}
}
if (!linkFields.isEmpty()) {
annotatedLinkFields.put(cl.getName(), linkFields);
}
totalFields = numberMandatoryFields + numberOptionalFields;
if (LOG.isDebugEnabled()) {
LOG.debug("Number of optional fields: {}", numberOptionalFields);
LOG.debug("Number of mandatory fields: {}", numberMandatoryFields);
LOG.debug("Total: {}", totalFields);
}
}
if (annotatedFields.size() < maxpos) {
LOG.info(
"Potentially incomplete model: some csv fields may not be mapped to @DataField members");
}
}
public void bind(List<String> tokens, Map<String, Object> model, int line) throws Exception {
int pos = 1;
int counterMandatoryFields = 0;
for (String data : tokens) {
// Get DataField from model
DataField dataField = dataFields.get(pos);
ObjectHelper.notNull(
dataField, "No position " + pos + " defined for the field: " + data + ", line: " + line);
if (dataField.trim()) {
data = data.trim();
}
if (dataField.required()) {
// Increment counter of mandatory fields
++counterMandatoryFields;
// Check if content of the field is empty
// This is not possible for mandatory fields
if (data.equals("")) {
throw new IllegalArgumentException(
"The mandatory field defined at the position "
+ pos
+ " is empty for the line: "
+ line);
}
}
// Get Field to be setted
Field field = annotatedFields.get(pos);
field.setAccessible(true);
if (LOG.isDebugEnabled()) {
LOG.debug("Pos: {}, Data: {}, Field type: {}", new Object[] {pos, data, field.getType()});
}
// Create format object to format the field
Format<?> format = FormatFactory.getFormat(field.getType(), getLocale(), dataField);
// field object to be set
Object modelField = model.get(field.getDeclaringClass().getName());
// format the data received
Object value = null;
if (!data.equals("")) {
try {
value = format.parse(data);
} catch (FormatException ie) {
throw new IllegalArgumentException(
ie.getMessage() + ", position: " + pos + ", line: " + line, ie);
} catch (Exception e) {
throw new IllegalArgumentException(
"Parsing error detected for field defined at the position: "
+ pos
+ ", line: "
+ line,
e);
}
} else {
if (!dataField.defaultValue().isEmpty()) {
value = format.parse(dataField.defaultValue());
} else {
value = getDefaultValueForPrimitive(field.getType());
}
}
field.set(modelField, value);
++pos;
}
LOG.debug("Counter mandatory fields: {}", counterMandatoryFields);
if (counterMandatoryFields < numberMandatoryFields) {
throw new IllegalArgumentException("Some mandatory fields are missing, line: " + line);
}
if (pos < totalFields) {
setDefaultValuesForFields(model);
}
}