コード例 #1
0
  protected static <T> void parseEDISegmentOrSegmentGroup(
      EDIMessage ediMessage,
      T object,
      Iterator<Field> fieldIterator,
      Queue<String> lookAhead,
      SegmentIterator segmentIterator)
      throws EDIMessageException, IllegalAccessException, InvocationTargetException,
          InstantiationException, ClassNotFoundException, ConversionException {
    if (!fieldIterator.hasNext()) {
      throw new EDIMessageException("No more fields to read.");
    }

    if (!segmentIterator.hasNext() && lookAhead.size() == 0) {
      return;
    }

    // get the queued object first...
    String line = lookAhead.size() > 0 ? lookAhead.remove() : segmentIterator.next();

    // match up the field with the line...
    FieldMatch fm = advanceToMatch(ediMessage, fieldIterator, line);

    //

    if (fm != null) {
      Class<?> fieldType = getEDISegmentOrGroupType(fm.getField());
      if (fieldType.isAnnotationPresent(EDISegment.class)) {
        processSegment(ediMessage, object, lookAhead, segmentIterator, fm);
      } else if (fieldType.isAnnotationPresent(EDISegmentGroup.class)) {
        processSegmentGroup(ediMessage, object, lookAhead, segmentIterator, fm);
      }
    } else {
      lookAhead.add(line);
    }
  }
コード例 #2
0
  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;
  }
コード例 #3
0
  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;
  }
コード例 #4
0
  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);
      }
    }
  }