protected static <T> T parseEDIMessage(Class<T> clz, Reader reader)
throws EDIMessageException, InstantiationException, IllegalAccessException,
InvocationTargetException, ClassNotFoundException, ConversionException {
if (!clz.isAnnotationPresent(EDIMessage.class)) {
throw new EDIMessageException("Not EDI Message Class.");
}
EDIMessage ediMessage = clz.getAnnotation(EDIMessage.class);
SegmentIterator segmentIterator =
new SegmentIterator(reader, ediMessage.segmentDelimiter(), true);
Field[] fields = clz.getDeclaredFields();
Iterator<Field> fieldIterator = Arrays.asList(fields).iterator();
T obj = clz.newInstance();
Queue<String> lookAhead = new LinkedList<String>();
while (fieldIterator.hasNext() && (segmentIterator.hasNext() || lookAhead.size() > 0)) {
parseEDISegmentOrSegmentGroup(ediMessage, obj, fieldIterator, lookAhead, segmentIterator);
}
return obj;
}
protected static Queue<String> queueLinesForType(
EDIMessage ediMessage,
EDISegment segment,
Queue<String> lookAhead,
SegmentIterator SegmentIterator) {
Queue<String> segments = new LinkedList<String>();
while (SegmentIterator.hasNext()) {
String line = SegmentIterator.next();
StringTokenizer tokenizer =
new StringTokenizer(line, CharUtils.toString(ediMessage.elementDelimiter()));
String token = tokenizer.nextToken();
if (StringUtils.equals(segment.tag(), token)) {
segments.add(line);
} else {
lookAhead.add(line);
break;
}
}
return segments;
}
protected static FieldMatch advanceToMatch(
EDIMessage ediMessage, Iterator<Field> fieldIterator, String line) {
// advance the reader, read the line.
StringTokenizer tokenizer =
new StringTokenizer(line, CharUtils.toString(ediMessage.elementDelimiter()));
// first token is always the tag.
String ediSegmentTag = tokenizer.nextToken();
while (fieldIterator.hasNext()) {
Field field = fieldIterator.next();
if (matchesSegment(field, ediSegmentTag)) {
LOG.debug(
"SegmentMatch[" + ediSegmentTag + " -> " + field.getType().getName() + "] :: " + line);
return new FieldMatch(field, line);
}
if (LOG.isDebugEnabled()) {
LOG.debug("Field: " + field + " does not match: " + line);
}
}
return null;
}
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);
}
}
}