001package ca.uhn.hl7v2.util;
002
003import ca.uhn.hl7v2.model.DataTypeException;
004import ca.uhn.hl7v2.HL7Exception;
005import ca.uhn.hl7v2.model.*;
006
007/**
008 * Tools for copying data recurvisely from one message element into another.  Currently only Types are 
009 * supported.  
010 * @author Bryan Tripp
011 */
012public class DeepCopy {
013    
014    /**
015     * Copies data from the "from" Type into the "to" Type.  Either Type may be 
016     * a Primitive, Composite, or Varies.  If a Varies is provided, the operation is 
017     * performed on the result of calling its getData() method.  A Primitive may be 
018     * copied into a Composite, in which case the value is copied into the first 
019     * component of the Composite.  A Composite may be copied into a Primitive, 
020     * in which case the first component is copied.  Given Composites with different 
021     * numbers of components, the first components are copied, up to the length 
022     * of the smaller one.  
023     */
024    public static void copy(Type from, Type to) throws DataTypeException {
025        for (int i = 1; i <= Terser.numComponents(from); i++) {
026            for (int j = 1; j <= Terser.numSubComponents(from, i); j++) {
027                String val = Terser.getPrimitive(from, i, j).getValue();
028                Terser.getPrimitive(to, i, j).setValue(val);
029            }
030        }
031    }
032    
033    /*    if (from instanceof Varies) {
034            from = ((Varies) from).getData();
035        }        
036        if (to instanceof Varies) {
037            to = ((Varies) to).getData();
038        }
039        if (from instanceof Primitive) {
040            if (to instanceof Primitive) {
041                copy((Primitive) from, (Primitive) to);
042            } else {
043                copy((Primitive) from, (Composite) to);                
044            }
045        } else {
046            if (to instanceof Primitive) {
047                copy((Composite) from, (Primitive) to);                
048            } else {
049                copy((Composite) from, (Composite) to);                
050            }            
051        }
052    }*/
053    
054    /** Copies a primitive to a primitive */
055    /*private static void copy(Primitive from, Primitive to) throws DataTypeException {
056        to.setValue(from.getValue());
057    }*/
058    
059    /** Copies composite to composite - could be different # of components (extras either way are ignored) */
060    /*private static void copy(Composite from, Composite to) throws DataTypeException {
061        Type[] froms = from.getComponents();
062        Type[] tos = to.getComponents();
063        int limit = Math.min(froms.length, tos.length);
064        for (int i = 0; i < limit; i++) {
065            copy(froms[i], tos[i]);
066        }
067    }*/
068    
069    /** Copies primitive to first component of composite.  */
070    /*private static void copy(Primitive from, Composite to) throws DataTypeException {
071        Type firstComponent = to.getComponent(0);
072        copy(from, firstComponent);
073    }*/
074    
075    /** Copies first component of composite to a primitive */
076    /*private static void copy(Composite from, Primitive to) throws DataTypeException {
077        Type firstComponent = from.getComponent(0);
078        copy(firstComponent, to);
079    }*/
080    
081    /**
082     * Copies contents from the source segment to the destination segment.  This 
083     * method calls copy(Type, Type) on each repetition of each field (see additional 
084     * behavioural description there).  An attempt is made to copy each repetition of 
085     * each field in the source segment, regardless of whether the corresponding 
086     * destination field is repeating or even exists.  
087     * @param from the segment from which data are copied 
088     * @param to the segment into which data are copied
089     */
090    public static void copy(Segment from, Segment to) throws HL7Exception {
091        int n = from.numFields();
092        for (int i = 1; i <= n; i++) {
093            Type[] reps = from.getField(i);
094            for (int j = 0; j < reps.length; j++) {
095                copy(reps[j], to.getField(i, j));
096            }
097        }
098    }
099}