Java tutorial
/** * 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 "" Description: * "" * * The Initial Developer of the Original Code is University Health Network. Copyright (C) * 2001. 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.testpanel.model.conf; import java.lang.reflect.InvocationTargetException; import org.apache.commons.lang.Validate; import ca.uhn.hl7v2.HL7Exception; import ca.uhn.hl7v2.Version; import ca.uhn.hl7v2.conf.ProfileException; import ca.uhn.hl7v2.conf.spec.message.Component; import ca.uhn.hl7v2.conf.spec.message.Field; import ca.uhn.hl7v2.conf.spec.message.ProfileStructure; import ca.uhn.hl7v2.conf.spec.message.Seg; import ca.uhn.hl7v2.conf.spec.message.SegGroup; import ca.uhn.hl7v2.conf.spec.message.StaticDef; import ca.uhn.hl7v2.conf.spec.message.SubComponent; import ca.uhn.hl7v2.model.AbstractMessage; import ca.uhn.hl7v2.model.DoNotCacheStructure; import ca.uhn.hl7v2.model.GenericSegment; import ca.uhn.hl7v2.model.Group; import ca.uhn.hl7v2.model.Message; import ca.uhn.hl7v2.model.Segment; import ca.uhn.hl7v2.model.Structure; import ca.uhn.hl7v2.model.Type; import ca.uhn.hl7v2.parser.ModelClassFactory; @DoNotCacheStructure public class ConformanceMessage extends AbstractMessage implements ConformanceStructureHolder { private final StaticDef myConfDefinition; private ConformanceStructureHolderSupport mySupport; private String myTablesId; public ConformanceMessage(StaticDef theConfDefinition) { super(new NullModelClassFactory()); mySupport = new ConformanceStructureHolderSupport(this, theConfDefinition); myConfDefinition = theConfDefinition; } public ConformanceMessage(StaticDef theConfDefinition, ConformanceStructureHolderSupport theSupport) { this(theConfDefinition); mySupport = theSupport; } /** * Internal method for adding child structures */ public void addChild(ConformanceStructure<?> theStructure, String theName, short theMinReps, short theMaxReps) throws HL7Exception { int num = mySupport.getChildCount(); mySupport.addChild(theStructure, theName, theMinReps, theMaxReps); super.insert(theStructure.getClass(), mySupport.isRequired(theName), mySupport.isRepeating(theName), num, theName); } /** * {@inheritDoc} */ @Override public Structure get(String theName, int theRep) throws HL7Exception { Validate.notEmpty(theName); Structure retVal = mySupport.getNonStandardSegmentIfNameExists(theName, theRep); if (retVal != null) { return retVal; } Structure[] currentReps = getAll(theName); int currentRepsNum = currentReps.length; if (theRep > currentRepsNum) { throw new HL7Exception("Can't create rep " + theRep + " as there are currently only " + currentRepsNum); } if (theRep < currentRepsNum) { return super.get(theName, theRep); } if (getClass(theName) == GenericSegment.class) { retVal = super.get(theName, theRep); } else { retVal = mySupport.get(theName, theRep); insertRepetition(theName, retVal, theRep); } return retVal; } /** * {@inheritDoc} */ @Override public Structure[] getAll(String theName) throws HL7Exception { Structure[] retVal = mySupport.getAllNonStandardSegmentsIfNameExists(theName); if (retVal == null) { return super.getAll(theName); } return retVal; } /** * @return the confDefinition */ public StaticDef getConfDefinition() { return myConfDefinition; } @Override public ConformanceMessage getMessage() { return this; } // /** // * {@inheritDoc} // */ // @Override // public String addNonstandardSegment(String theName) throws HL7Exception { // String segment = mySupport.addNonstandardSegment(theName); // return segment; // } // // /** // * {@inheritDoc} // */ // @Override // public String addNonstandardSegment(String theName, int theIndex) throws HL7Exception { // return mySupport.addNonstandardSegment(theName, theIndex); // } /** * {@inheritDoc} */ @Override public String getName() { return myConfDefinition.getMsgStructID(); } /** * @return the tablesId */ public String getTablesId() { return myTablesId; } // /** // * {@inheritDoc} // */ // @Override // public String[] getNames() { // String[] retVal = mySupport.getNames(); // return retVal; // } private void setTablesId(String theTablesId) { myTablesId = theTablesId; } /** * {@inheritDoc} */ @Override protected Structure tryToInstantiateStructure(Class<? extends Structure> theC, String theName) throws HL7Exception { if (theC.equals(GenericSegment.class)) { try { return theC.getConstructor(Group.class, String.class).newInstance(this, theName); } catch (InstantiationException e) { throw new HL7Exception(e); } catch (IllegalAccessException e) { throw new HL7Exception(e); } catch (IllegalArgumentException e) { throw new HL7Exception(e); } catch (SecurityException e) { throw new HL7Exception(e); } catch (InvocationTargetException e) { throw new HL7Exception(e); } catch (NoSuchMethodException e) { throw new HL7Exception(e); } } return mySupport.get(theName, 0); } private static void addChildren(ConformanceStructureHolder theParent, Seg theChildDef) throws HL7Exception { ConformanceSegment segment = new ConformanceSegment(theParent, theChildDef); theParent.addChild(segment, theChildDef.getName(), theChildDef.getMin(), theChildDef.getMax()); for (int i = 0; i < theChildDef.getFields(); i++) { Field fieldDef = theChildDef.getField(i + 1); if (fieldDef.getComponents() == 0) { addPrimitive(segment, fieldDef); } else { ConformanceComposite field = new ConformanceComposite(((ConformanceMessage) theParent.getMessage()), fieldDef); for (int j = 0; j < fieldDef.getComponents(); j++) { Component componentDef = fieldDef.getComponent(j + 1); if (componentDef.getSubComponents() == 0) { addPrimitive(field, componentDef); } else { ConformanceComposite component = new ConformanceComposite( ((ConformanceMessage) theParent.getMessage()), componentDef); for (int k = 0; k < componentDef.getSubComponents(); k++) { SubComponent subComponentDef = componentDef.getSubComponent(k + 1); ConformancePrimitive subComponent = new ConformancePrimitive(theParent.getMessage(), subComponentDef); component.addChild(subComponent, subComponentDef.getName()); } field.addChild(component, componentDef.getName()); } } segment.addChild(field, fieldDef.getName(), fieldDef.getMin(), fieldDef.getMax(), (int) fieldDef.getLength()); } } } private static void addChildren(ConformanceStructureHolder theParent, SegGroup theChildDef) throws HL7Exception { if (theChildDef.getChildren() == 1 && theChildDef.getChild(1) instanceof SegGroup) { SegGroup child = (SegGroup) theChildDef.getChild(1); try { if (theChildDef.getMin() == 0) { child.setMin(theChildDef.getMin()); } if (theChildDef.getMax() == -1) { child.setMax(theChildDef.getMax()); } if (theChildDef.getName().length() > child.getName().length()) { child.setName(theChildDef.getName()); } } catch (ProfileException e) { throw new HL7Exception(e); } theChildDef = child; } ConformanceGroup child = new ConformanceGroup(theParent, theChildDef); theParent.addChild(child, theChildDef.getName(), theChildDef.getMin(), theChildDef.getMax()); for (int i = 0; i < theChildDef.getChildren(); i++) { ProfileStructure childDef = theChildDef.getChild(i + 1); if (childDef instanceof Seg) { addChildren(child, (Seg) childDef); } else { addChildren(child, (SegGroup) childDef); } } } private static void addPrimitive(ConformanceComposite theComposite, Component theChild) { ConformancePrimitive primitive = new ConformancePrimitive(theComposite.getMessage(), theChild); theComposite.addChild(primitive, theChild.getName()); } private static void addPrimitive(ConformanceSegment theSegment, Field theField) throws HL7Exception { ConformancePrimitive primitive = new ConformancePrimitive(theSegment.getMessage(), theField); theSegment.addChild(primitive, theField.getName(), theField.getMin(), theField.getMax(), (int) theField.getLength()); } public static ConformanceMessage newInstanceFromStaticDef(StaticDef theStaticDef, String theTablesId) throws HL7Exception { ConformanceMessage retVal = new ConformanceMessage(theStaticDef); for (int i = 0; i < theStaticDef.getChildren(); i++) { ProfileStructure childDef = theStaticDef.getChild(i + 1); if (childDef instanceof Seg) { addChildren(retVal, (Seg) childDef); } else { addChildren(retVal, (SegGroup) childDef); } } retVal.setTablesId(theTablesId); return retVal; } /** * Null implementation of MCF - Always throws UnsupportedOperationException */ private static class NullModelClassFactory implements ModelClassFactory { public Class<? extends Group> getGroupClass(String theName, String theVersion) throws HL7Exception { throw new UnsupportedOperationException(); } public Class<? extends Message> getMessageClass(String theName, String theVersion, boolean theIsExplicit) throws HL7Exception { throw new UnsupportedOperationException(); } public Class<? extends Message> getMessageClassInASpecificPackage(String theName, String theVersion, boolean theIsExplicit, String thePackageName) throws HL7Exception { throw new UnsupportedOperationException(); } public Class<? extends Segment> getSegmentClass(String theName, String theVersion) throws HL7Exception { return GenericSegment.class; } public Class<? extends Type> getTypeClass(String theName, String theVersion) throws HL7Exception { throw new UnsupportedOperationException(); } @Override public String getMessageStructureForEvent(String theEventName, Version theVersion) throws HL7Exception { throw new UnsupportedOperationException(); } } }