protected static <T> void processSegment(
EDIMessage ediMessage,
T object,
Queue<String> lookAhead,
SegmentIterator SegmentIterator,
FieldMatch fm)
throws InstantiationException, IllegalAccessException, InvocationTargetException,
ClassNotFoundException, ConversionException {
if (Collection.class.isAssignableFrom(fm.getField().getType())) {
Collection obj = CollectionFactory.newInstance(fm.getField().getType());
BeanUtils.setProperty(object, fm.getField().getName(), obj);
// look ahead to see if we need to break.
Class<?> collectionClass = getCollectionType(fm.getField());
if (collectionClass.isAnnotationPresent(EDISegment.class)) {
EDISegment es = collectionClass.getAnnotation(EDISegment.class);
// first, go ahead and add the object from the field match.
Object matchObject = collectionClass.newInstance();
parseEDISegmentFields(ediMessage, matchObject, fm.getLine());
obj.add(matchObject);
Queue<String> segments = queueLinesForType(ediMessage, es, lookAhead, SegmentIterator);
for (String segment : segments) {
Object collectionObject = collectionClass.newInstance();
parseEDISegmentFields(ediMessage, collectionObject, segment);
obj.add(collectionObject);
}
}
} else {
Object obj = fm.getField().getType().newInstance();
BeanUtils.setProperty(object, fm.getField().getName(), obj);
parseEDISegmentFields(ediMessage, obj, fm.getLine());
}
}
protected static <T> void parseEDISegmentFields(
EDIMessage ediMessage, Object segment, String segmentLine)
throws IllegalAccessException, InvocationTargetException, ClassNotFoundException,
ConversionException, InstantiationException {
if (LOG.isDebugEnabled()) {
LOG.debug("Before Field Values: " + ReflectionToStringBuilder.toString(segment));
LOG.debug("Segment Values: " + segmentLine);
}
// now, tokenize the line, and set the fields.
StrTokenizer tokenizer = new StrTokenizer(segmentLine, ediMessage.elementDelimiter());
tokenizer.setEmptyTokenAsNull(true);
tokenizer.setIgnoreEmptyTokens(false);
// move past the initial tag.
tokenizer.next();
Iterator<Field> fieldIterator =
Arrays.asList(segment.getClass().getDeclaredFields()).iterator();
while (tokenizer.hasNext() && fieldIterator.hasNext()) {
Field field = fieldIterator.next();
String val = tokenizer.nextToken();
// check field to see if it is a component of regular field type.
if (field.isAnnotationPresent(EDIComponent.class)) {
EDIComponent ediComponent = field.getAnnotation(EDIComponent.class);
Collection obj = CollectionFactory.newInstance(field.getType());
Class objType = getCollectionType(field);
char componentDelimiter =
ediComponent.delimiter() == Character.UNASSIGNED
? ediMessage.componentDelimiter()
: ediComponent.delimiter();
// parse each element to the collection.
StrTokenizer componentTokenizer = new StrTokenizer(val, componentDelimiter);
componentTokenizer.setEmptyTokenAsNull(true);
componentTokenizer.setIgnoreEmptyTokens(false);
while (componentTokenizer.hasNext()) {
String component = componentTokenizer.nextToken();
Object fieldObj =
objType.cast(FieldAwareConverter.convertFromString(objType, field, component));
obj.add(fieldObj);
}
BeanUtils.setProperty(segment, field.getName(), obj);
} else {
if (val == null) {
LOG.debug(" " + field.getName() + " -> null");
continue;
}
// try and populate the field.
try {
Object fieldObj = FieldAwareConverter.convertFromString(field.getType(), field, val);
LOG.debug(" " + field.getName() + " -> " + val);
BeanUtils.setProperty(segment, field.getName(), fieldObj);
} catch (Exception e) {
throw new ConversionException(
"Exception setting: "
+ segment.getClass()
+ "."
+ field.getName()
+ " with value: "
+ val,
e);
}
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("After Field Values: " + ReflectionToStringBuilder.toString(segment));
}
}
protected static <T> void processSegmentGroup(
EDIMessage ediMessage,
T object,
Queue<String> lookAhead,
SegmentIterator segmentIterator,
FieldMatch fm)
throws InstantiationException, IllegalAccessException, InvocationTargetException,
ClassNotFoundException, ConversionException, EDIMessageException {
LOG.debug("Object: " + ReflectionToStringBuilder.toString(object));
LOG.debug("Field: " + fm.getField().getName());
Class<?> segmentGroupClass = getEDISegmentOrGroupType(fm.getField());
if (!segmentGroupClass.isAnnotationPresent(EDISegmentGroup.class)) {
throw new EDIMessageException("Segment Group should have annotation.");
}
LOG.debug("Segment Group Type: " + segmentGroupClass);
String line = fm.getLine();
EDISegmentGroup es = segmentGroupClass.getAnnotation(EDISegmentGroup.class);
if (StringUtils.equals(es.header(), line)) {
// feed line.
} else {
LOG.debug("Adding to Look Ahead: " + line);
lookAhead.add(line);
}
if (Collection.class.isAssignableFrom(fm.getField().getType())) {
Collection obj = CollectionFactory.newInstance(fm.getField().getType());
BeanUtils.setProperty(object, fm.getField().getName(), obj);
String segmentTag = getSegmentTag(fm.getField(), true);
while (true) {
LOG.debug("Looping to collect Collection of Segment Groups");
// parse the group...
Field[] fields = segmentGroupClass.getDeclaredFields();
final List<Field> fieldsList = Arrays.asList(fields);
ListIterator<Field> fieldIterator = fieldsList.listIterator(0);
Object collectionObj = segmentGroupClass.newInstance();
while (fieldIterator.hasNext() && (segmentIterator.hasNext() || lookAhead.size() > 0)) {
if (startOfNewRecursiveObject(fieldIterator, fieldsList, segmentGroupClass)) {
String next = lookAhead.size() > 0 ? lookAhead.remove() : segmentIterator.next();
lookAhead.add(next);
if (!isSegmentHeirarchicalLevelAndDeeperLevel(
line, next, Character.toString(ediMessage.elementDelimiter()))) {
LOG.debug("Reaching new instance of list.");
break;
}
}
parseEDISegmentOrSegmentGroup(
ediMessage, collectionObj, fieldIterator, lookAhead, segmentIterator);
}
obj.add(collectionObj);
// look to next line...
String nextLine = lookAhead.size() > 0 ? lookAhead.remove() : segmentIterator.next();
// get the first element of the line.
StrTokenizer nextLineTokenizer = new StrTokenizer(nextLine, ediMessage.elementDelimiter());
if (StringUtils.equals(segmentTag, nextLineTokenizer.nextToken())) {
if (!isSegmentEqual(line, nextLine, Character.toString(ediMessage.elementDelimiter()))) {
LOG.debug("Reaching new collection");
lookAhead.add(nextLine);
break;
}
LOG.debug("Might be a repeat..");
LOG.debug("Next line: " + line);
lookAhead.add(nextLine);
} else {
lookAhead.add(nextLine);
break;
}
// now, look ahead to see whether the next line is of the same
// object type..
if (!segmentIterator.hasNext() && lookAhead.size() == 0) {
break;
}
}
} else {
Field[] fields = segmentGroupClass.getDeclaredFields();
Iterator<Field> fieldIterator = Arrays.asList(fields).iterator();
Object obj = segmentGroupClass.newInstance();
while (fieldIterator.hasNext() && (segmentIterator.hasNext() || lookAhead.size() > 0)) {
parseEDISegmentOrSegmentGroup(ediMessage, obj, fieldIterator, lookAhead, segmentIterator);
}
BeanUtils.setProperty(object, fm.getField().getName(), obj);
}
// look at next...
if (StringUtils.isNotBlank(es.header())) {
line = lookAhead.size() > 0 ? lookAhead.remove() : segmentIterator.next();
if (StringUtils.endsWith(es.footer(), line)) {
// feed line.
LOG.debug("Popping footer off of the line iterator.");
} else {
lookAhead.add(line);
}
}
}