/**

  * The contents of this file are subject to the Mozilla Public License Version 1.1

  * (the "License"); you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at http://www.mozilla.org/MPL/

  * Software distributed under the License is distributed on an "AS IS" basis,

  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the

  * specific language governing rights and limitations under the License.

  *

  * The Original Code is "ReadOnlyMessageIterator.java".  Description:

  * "Iterator though existing Stuctures in a message.   "

  *

  * The Initial Developer of the Original Code is University Health Network. Copyright (C)

  * 2005.  All Rights Reserved.

  *

  * Contributor(s): ______________________________________.

  *

  * Alternatively, the contents of this file may be used under the terms of the

  * GNU General Public License (the "GPL"), in which case the provisions of the GPL are

  * applicable instead of those above.  If you wish to allow use of your version of this

  * file only under the terms of the GPL and not to allow others to use your version

  * of this file under the MPL, indicate your decision by deleting  the provisions above

  * and replace  them with the notice and other provisions required by the GPL License.

  * If you do not delete the provisions above, a recipient may use your version of

  * this file under either the MPL or the GPL.

  *

  */

 package ca.uhn.hl7v2.util;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.List;

 import java.util.NoSuchElementException;

 import ca.uhn.hl7v2.HL7Exception;

 import ca.uhn.hl7v2.model.Group;

 import ca.uhn.hl7v2.model.Segment;

 import ca.uhn.hl7v2.model.Structure;

 /**

  * Iterator though existing Stuctures in a message.  No new repetitions or optional 

  * structures are created during iteration (in contrast to MessageIterator).  

  * 

  * Note that some structures are created during parsing, so the iteration may include 

  * structures which were not present in the original encoded message.  If these are 

  * not desired they can be skipped using a FilterIterator.  In fact to obtain an  

  * iterator only over populated segments (not groups or empty segments) use the factory 

  * method in this class.  

  *  

  * @author <a href="mailto:bryan.tripp@uhn.on.ca">Bryan Tripp</a>

  * @version $Revision: 1.1 $ updated on $Date: 2007-02-19 02:24:27 $ by $Author: jamesagnew $

  */

 public class ReadOnlyMessageIterator implements Iterator<Structure> {

     private List<Structure> myRemaining; //remaining nodes in reverse order (i.e. last is next)

     /**

      * @param theRoot root of depth first iteration, which starts with the first child  

      */

     public ReadOnlyMessageIterator(Group theRoot) {

         myRemaining = new ArrayList<Structure>(40);

         addChildren(theRoot);

     }

     /**

      * @param theRoot root of depth first iteration, which starts with the first child

      * @return an iterator that skips groups and empty segments, returning only populated 

      *      segments  

      */

     public static Iterator<Structure> createPopulatedSegmentIterator(Group theRoot) {

         return createPopulatedStructureIterator(theRoot, Segment.class);       

     }

     /**

      * @param theRoot root of depth first iteration, which starts with the first child

      * @param c structure class to look for

      * @return an iterator that skips all structures that do not match the parameter

      */

     public static Iterator<Structure> createPopulatedStructureIterator(Group theRoot, Class<? extends Structure> c) {

         return createPopulatedStructureIterator(theRoot, new StructurePredicate(c));       

     }    

     /**

      * @param theRoot root of depth first iteration, which starts with the first child

      * @param structureName structure name to look for

      * @return an iterator that skips all structures that do not match the parameter

      */

     public static Iterator<Structure> createPopulatedStructureIterator(Group theRoot, String structureName) {

         return createPopulatedStructureIterator(theRoot, new StructureNamePredicate(structureName));

     }

     /**

      * @param theRoot root of depth first iteration, which starts with the first child

      * @param structureFilter filter class

      * @return iterator that skips all structures that the filter does not accept

      */

     public static Iterator<Structure> createPopulatedStructureIterator(Group theRoot, FilterIterator.Predicate<Structure> structureFilter) {

         Iterator<Structure> allIterator = new ReadOnlyMessageIterator(theRoot);

         Iterator<Structure> structureIterator = new FilterIterator<Structure>(allIterator, structureFilter);

         FilterIterator.Predicate<Structure> populatedOnly = new FilterIterator.Predicate<Structure>() {

             public boolean evaluate(Structure obj) {

                 try {

                     return !obj.isEmpty();

                 } catch (HL7Exception e) {

                     return false; // no exception expected

                 }

             }

         };

         return new FilterIterator<Structure>(structureIterator, populatedOnly);         

     }

     private void addChildren(Group theParent) {

         String[] names = theParent.getNames();

         for (int i = names.length - 1; i >= 0; i--) {

             try {

                 Structure[] reps = theParent.getAll(names[i]);

                 for (int j = reps.length - 1; j >= 0; j--) {

                     myRemaining.add(reps[j]);

                 }

             } catch (HL7Exception e) {

                 throw new Error("Internal error: an invalid child name was obtained from its parent.");

             }

         }

     }

     /** 

      * @see java.util.Iterator#hasNext()

      */

     public boolean hasNext() {

         return !myRemaining.isEmpty();

     }

     /** 

      * @see java.util.Iterator#next()

      */

     public Structure next() {

         if (!hasNext()) {

             throw new NoSuchElementException("No more nodes in message");

         }

         Structure next = myRemaining.remove(myRemaining.size() - 1);

         if (next instanceof Group) {

             addChildren((Group) next);

         }

         return next;

     }

     /** 

      * Not supported.  

      */

     public void remove() {

         throw new UnsupportedOperationException("Can't remove a node from a message");

     }

 }