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); } } }