/// <summary> Fills in the details of an Application Reject message, including response and /// error codes, and a text error message. This is the method to override if you want /// to respond differently. /// </summary> public virtual void fillDetails(Message ack) { try { //populate MSA and ERR with generic error ... Segment msa = (Segment) ack.get_Renamed("MSA"); Terser.set_Renamed(msa, 1, 0, 1, 1, "AR"); Terser.set_Renamed(msa, 3, 0, 1, 1, "No appropriate destination could be found to which this message could be routed."); //this is max length //populate ERR segment if it exists (may not depending on version) Structure s = ack.get_Renamed("ERR"); if (s != null) { Segment err = (Segment) s; Terser.set_Renamed(err, 1, 0, 4, 1, "207"); Terser.set_Renamed(err, 1, 0, 4, 2, "Application Internal Error"); Terser.set_Renamed(err, 1, 0, 4, 3, "HL70357"); } } catch (System.Exception e) { throw new NuGenApplicationException("Error trying to create Application Reject message: " + e.Message); } }
/// <summary> Creates new GroupPointer </summary> public NuGenMessagePointer(NuGenPipeParser parser, Message message, NuGenEncodingCharacters encodingChars) { this.parser = parser; this.message = message; this.encodingChars = encodingChars; makeChildren(); }
/// <param name="message">a parsed message to validate (note that MSH-9-1 and MSH-9-2 must be valued) /// </param> /// <returns> true if the message is OK /// </returns> /// <throws> HL7Exception if there is at least one error and this validator is set to fail on errors </throws> public virtual bool validate(Message message) { Terser t = new Terser(message); NuGenMessageRule[] rules = myContext.getMessageRules(message.Version, t.get_Renamed("MSH-9-1"), t.get_Renamed("MSH-9-2")); NuGenValidationException toThrow = null; bool result = true; for (int i = 0; i < rules.Length; i++) { NuGenValidationException[] ex = rules[i].test(message); for (int j = 0; j < ex.Length; j++) { result = false; if (failOnError && toThrow == null) { toThrow = ex[j]; } } } if (toThrow != null) { throw new NuGenHL7Exception("Invalid message", toThrow); } return result; }
/// <summary> Creates a CK_ACCOUNT_NO.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CK_ACCOUNT_NO(Message message) : base(message) { data = new Type[4]; data[0] = new NM(message); data[1] = new NM(message); data[2] = new ID(message, 0); data[3] = new ID(message, 0); }
/// <summary> Creates a CM_NDL.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CM_NDL(Message message) : base(message) { data = new Type[4]; data[0] = new CN(message); data[1] = new TS(message); data[2] = new TS(message); data[3] = new CM_INTERNAL_LOCATION(message); }
/// <summary> Creates a EI.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public EI(Message message) : base(message) { data = new Type[4]; data[0] = new ST(message); data[1] = new IS(message, 300); data[2] = new ST(message); data[3] = new ID(message, 301); }
/// <summary> Creates a RP.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public RP(Message message) : base(message) { data = new Type[4]; data[0] = new ST(message); data[1] = new HD(message); data[2] = new ID(message, 0); data[3] = new ID(message, 0); }
/// <summary> Creates a PTA.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public PTA(Message message) : base(message) { data = new Type[4]; data[0] = new IS(message, 147); data[1] = new IS(message, 193); data[2] = new NM(message); data[3] = new MOP(message); }
/// <summary> Creates a PLN.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public PLN(Message message) : base(message) { data = new Type[4]; data[0] = new ST(message); data[1] = new IS(message, 0); data[2] = new ST(message); data[3] = new DT(message); }
/// <summary> Creates a RMC.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public RMC(Message message) : base(message) { data = new Type[4]; data[0] = new IS(message, 145); data[1] = new IS(message, 146); data[2] = new NM(message); data[3] = new MOP(message); }
/// <summary> Creates a CM_ABS_RANGE.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CM_ABS_RANGE(Message message) : base(message) { data = new Type[4]; data[0] = new CM_RANGE(message); data[1] = new NM(message); data[2] = new NM(message); data[3] = new NM(message); }
/// <summary> Creates a QSC.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public QSC(Message message) : base(message) { data = new Type[4]; data[0] = new ST(message); data[1] = new ID(message, 209); data[2] = new ST(message); data[3] = new ID(message, 210); }
/// <summary> Creates a DLT.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public DLT(Message message) : base(message) { data = new Type[4]; data[0] = new NR(message); data[1] = new NM(message); data[2] = new ST(message); data[3] = new NM(message); }
/// <summary> Formats a Message object into an HL7 message string using the given /// encoding. /// </summary> /// <throws> HL7Exception if the data fields in the message do not permit encoding </throws> /// <summary> (e.g. required fields are null) /// </summary> /// <throws> EncodingNotSupportedException if the requested encoding is not </throws> /// <summary> supported by this parser. /// </summary> protected internal override System.String doEncode(Message source, System.String encoding) { if (!encoding.Equals("XML")) { throw new NuGenEncodingNotSupportedException("XMLParser supports only XML encoding"); } return(encode(source)); }
/// <summary> Creates a NA.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public NA(Message message) : base(message) { data = new Type[4]; data[0] = new NM(message); data[1] = new NM(message); data[2] = new NM(message); data[3] = new NM(message); }
/// <summary> <p>Creates and populates a Message object from an XML Document that contains an XML-encoded HL7 message.</p> /// <p>The easiest way to implement this method for a particular message structure is as follows: /// <ol><li>Create an instance of the Message type you are going to handle with your subclass /// of XMLParser</li> /// <li>Go through the given Document and find the Elements that represent the top level of /// each message segment. </li> /// <li>For each of these segments, call <code>parse(Segment segmentObject, Element segmentElement)</code>, /// providing the appropriate Segment from your Message object, and the corresponding Element.</li></ol> /// At the end of this process, your Message object should be populated with data from the XML /// Document.</p> /// </summary> /// <throws> HL7Exception if the message is not correctly formatted. </throws> /// <throws> EncodingNotSupportedException if the message encoded </throws> /// <summary> is not supported by this parser. /// </summary> public override Message parseDocument(System.Xml.XmlDocument XMLMessage, System.String version) { System.String messageName = ((System.Xml.XmlElement)XMLMessage.DocumentElement).Name; Message message = instantiateMessage(messageName, version, true); parse(message, (System.Xml.XmlElement)XMLMessage.DocumentElement); return(message); }
/// <summary> Creates a ELD.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public ELD(Message message) : base(message) { data = new Type[4]; data[0] = new ST(message); data[1] = new NM(message); data[2] = new NM(message); data[3] = new CE(message); }
/// <summary> Returns the Applications that has been registered to handle /// messages of the type and trigger event of the given message, or null if /// there are none. /// </summary> private NuGenApplication getMatchingApplication(Message message) { Terser t = new Terser(message); System.String messageType = t.get_Renamed("/MSH-9-1"); System.String triggerEvent = t.get_Renamed("/MSH-9-2"); return(this.getMatchingApplication(messageType, triggerEvent)); }
/// <summary> Creates a VH.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public VH(Message message) : base(message) { data = new Type[4]; data[0] = new ID(message, 0); data[1] = new ID(message, 0); data[2] = new TM(message); data[3] = new TM(message); }
/// <summary> Creates a CM_SPD.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CM_SPD(Message message) : base(message) { data = new Type[4]; data[0] = new ST(message); data[1] = new ST(message); data[2] = new ID(message, 0); data[3] = new DT(message); }
/// <summary> Logs the given exception and creates an error message to send to the /// remote system. /// /// </summary> /// <param name="encoding">The encoding for the error message. If <code>null</code>, uses default encoding /// </param> public static System.String logAndMakeErrorMessage(System.Exception e, Segment inHeader, Parser p, System.String encoding) { // create error message ... System.String errorMessage = null; try { Message out_Renamed = NuGenDefaultApplication.makeACK(inHeader); Terser t = new Terser(out_Renamed); //copy required data from incoming message ... try { t.set_Renamed("/MSH-10", MessageIDGenerator.Instance.NewID); } catch (System.IO.IOException ioe) { throw new NuGenHL7Exception("Problem creating error message ID: " + ioe.Message); } //populate MSA ... t.set_Renamed("/MSA-1", "AE"); //should this come from HL7Exception constructor? t.set_Renamed("/MSA-2", Terser.get_Renamed(inHeader, 10, 0, 1, 1)); System.String excepMessage = e.Message; if (excepMessage != null) { t.set_Renamed("/MSA-3", excepMessage.Substring(0, (System.Math.Min(80, excepMessage.Length)) - (0))); } /* Some earlier ACKs don't have ERRs, but I think we'll change this within HAPI * so that there is a single ACK for each version (with an ERR). */ //see if it's an HL7Exception (so we can get specific information) ... if (e.GetType().Equals(typeof(NuGenHL7Exception))) { Segment err = (Segment)out_Renamed.get_Renamed("ERR"); ((NuGenHL7Exception)e).populate(err); } else { t.set_Renamed("/ERR-1-4-1", "207"); t.set_Renamed("/ERR-1-4-2", "Application Internal Error"); t.set_Renamed("/ERR-1-4-3", "HL70357"); } if (encoding != null) { errorMessage = p.encode(out_Renamed, encoding); } else { errorMessage = p.encode(out_Renamed); } } catch (System.IO.IOException ioe) { throw new NuGenHL7Exception("IOException creating error response message: " + ioe.Message, NuGenHL7Exception.APPLICATION_INTERNAL_ERROR); } return(errorMessage); }
/// <summary> Creates a ED.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public ED(Message message) : base(message) { data = new Type[5]; data[0] = new HD(message); data[1] = new ID(message, 191); data[2] = new ID(message, 291); data[3] = new ID(message, 299); data[4] = new ST(message); }
/// <summary> Formats a Message object into an HL7 message string using the given /// encoding. /// </summary> /// <throws> HL7Exception if the data fields in the message do not permit encoding </throws> /// <summary> (e.g. required fields are null) /// </summary> /// <throws> EncodingNotSupportedException if the requested encoding is not </throws> /// <summary> supported by this parser. /// </summary> protected internal override System.String doEncode(Message source, System.String encoding) { if (!this.supportsEncoding(encoding)) { throw new NuGenEncodingNotSupportedException("This parser does not support the " + encoding + " encoding"); } return(encode(source)); }
/// <summary> Creates a CM_SPS.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CM_SPS(Message message) : base(message) { data = new Type[5]; data[0] = new CE(message); data[1] = new TX(message); data[2] = new TX(message); data[3] = new CE(message); data[4] = new CE(message); }
/// <summary> Creates a FN.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public FN(Message message) : base(message) { data = new Type[5]; data[0] = new ST(message); data[1] = new ST(message); data[2] = new ST(message); data[3] = new ST(message); data[4] = new ST(message); }
/// <summary> Creates a PIP.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public PIP(Message message) : base(message) { data = new Type[5]; data[0] = new CE(message); data[1] = new CE(message); data[2] = new DT(message); data[3] = new DT(message); data[4] = new EI(message); }
/// <summary> Creates a CM_PAT_ID_0192.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CM_PAT_ID_0192(Message message) : base(message) { data = new Type[5]; data[0] = new ST(message); data[1] = new NM(message); data[2] = new ID(message, 0); data[3] = new ID(message, 0); data[4] = new ID(message, 192); }
/// <summary> Creates a CF.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CF(Message message) : base(message) { data = new Type[6]; data[0] = new ID(message, 0); data[1] = new FT(message); data[2] = new IS(message, 0); data[3] = new ID(message, 0); data[4] = new FT(message); data[5] = new IS(message, 0); }
/// <summary> Creates a MA.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public MA(Message message) : base(message) { data = new Type[6]; data[0] = new NM(message); data[1] = new NM(message); data[2] = new NM(message); data[3] = new NM(message); data[4] = new NM(message); data[5] = new NM(message); }
/// <summary> Creates a CD.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CD(Message message) : base(message) { data = new Type[6]; data[0] = new WVI(message); data[1] = new WVS(message); data[2] = new CSU(message); data[3] = new CCP(message); data[4] = new NM(message); data[5] = new NR(message); }
/// <summary> Creates a CP.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CP(Message message) : base(message) { data = new Type[6]; data[0] = new MO(message); data[1] = new ID(message, 205); data[2] = new NM(message); data[3] = new NM(message); data[4] = new CE(message); data[5] = new ID(message, 298); }
/// <summary> Creates a PN.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public PN(Message message) : base(message) { data = new Type[6]; data[0] = new FN(message); data[1] = new ST(message); data[2] = new ST(message); data[3] = new ST(message); data[4] = new ST(message); data[5] = new IS(message, 0); }
/// <summary> Formats a Message object into an HL7 message string using this parser's /// default encoding. /// /// </summary> /// <param name="source">a Message object from which to construct an encoded message string /// </param> /// <param name="encoding">the name of the encoding to use (eg "XML"; most implementations support only one /// encoding) /// </param> /// <returns> the encoded message /// </returns> /// <throws> HL7Exception if the data fields in the message do not permit encoding </throws> /// <summary> (e.g. required fields are null) /// </summary> public virtual System.String encode(Message source) { System.String encoding = DefaultEncoding; myValidator.validate(source); System.String result = doEncode(source); myValidator.validate(result, encoding.Equals("XML"), source.Version); return(result); }
/// <param name="theMessage">a message from which to extract fields /// </param> /// <param name="theTerserPaths">a list of paths to desired fields, in the /// form required by <code>Terser</code>. /// </param> /// <returns> a Map from Terser paths to field values /// </returns> public static System.Collections.IDictionary getFields(Message theMessage, System.Collections.IList theTerserPaths) { System.Collections.IDictionary fields = new System.Collections.Hashtable(); Terser terser = new Terser(theMessage); for (int i = 0; i < theTerserPaths.Count; i++) { System.String path = (System.String) theTerserPaths[i]; System.String fieldValue = terser.get_Renamed(path); fields[path] = fieldValue; } return fields; }
/// <summary> Forwards the given message to any Applications that have been registered to /// accept messages of that type and trigger event. /// </summary> /// <throws> ApplicationException if no such Applications are registered, or if </throws> /// <summary> the underlying Application throws this exception during processing. /// </summary> public virtual Message processMessage(Message in_Renamed) { Message out_Renamed; try { NuGenApplication matchingApp = this.getMatchingApplication(in_Renamed); out_Renamed = matchingApp.processMessage(in_Renamed); } catch (NuGenHL7Exception e) { throw new NuGenApplicationException("Error internally routing message: " + e.ToString(), e); } return out_Renamed; }
/// <summary> Creates and returns an acknowledgement -- the details are determined by fillDetails().</summary> public virtual Message processMessage(Message in_Renamed) { Message out_Renamed = null; try { //get default ACK out_Renamed = makeACK((Segment) in_Renamed.get_Renamed("MSH")); fillDetails(out_Renamed); } catch (System.Exception e) { throw new NuGenApplicationException("Couldn't create response message: " + e.Message); } return out_Renamed; }
/// <seealso cref="Genetibase.NuGenHL7.protocol.ReceivingApplication.processMessage(Genetibase.NuGenHL7.model.Message, java.util.Map)"> /// </seealso> public virtual Message processMessage(Message theMessage, System.Collections.IDictionary theMetadata) { Message result = null; try { result = myApplication.processMessage(theMessage); } catch (ApplicationException e) { throw new NuGenReceivingApplicationException(e); } return result; }
/// <summary> Returns true if at least one application has been registered to accept this /// type of message. Applications are registered using <code>registerApplication(...)</code>. /// </summary> public virtual bool canProcess(Message in_Renamed) { bool can = false; try { NuGenApplication matches = this.getMatchingApplication(in_Renamed); if (matches != null) can = true; } catch (NuGenHL7Exception) { can = false; } return can; }
/// <summary> Encodes the given message and compares it to the given string. Any differences /// are noted in the file [hapi.home]/parse_check.txt. Ignores extra field delimiters. /// </summary> public static void checkParse(System.String originalMessageText, Message parsedMessage, Parser parser) { System.String newMessageText = parser.encode(parsedMessage); if (!originalMessageText.Equals(newMessageText)) { //check each segment SupportClass.Tokenizer tok = new SupportClass.Tokenizer(originalMessageText, "\r"); System.Collections.ArrayList one = new System.Collections.ArrayList(); while (tok.HasMoreTokens()) { System.String seg = tok.NextToken(); if (seg.Length > 4) one.Add(seg); } tok = new SupportClass.Tokenizer(newMessageText, "\r"); System.Collections.ArrayList two = new System.Collections.ArrayList(); while (tok.HasMoreTokens()) { System.String seg = tok.NextToken(); if (seg.Length > 4) two.Add(stripExtraDelimiters(seg, seg[3])); } if (one.Count != two.Count) { } else { //check each segment for (int i = 0; i < one.Count; i++) { System.String origSeg = (System.String) one[i]; System.String newSeg = (System.String) two[i]; if (!origSeg.Equals(newSeg)) { } } } } else { } }
/// <summary> <p>Creates an XML Document that corresponds to the given Message object. </p> /// <p>If you are implementing this method, you should create an XML Document, and insert XML Elements /// into it that correspond to the groups and segments that belong to the message type that your subclass /// of XMLParser supports. Then, for each segment in the message, call the method /// <code>encode(Segment segmentObject, Element segmentElement)</code> using the Element for /// that segment and the corresponding Segment object from the given Message.</p> /// </summary> public override System.Xml.XmlDocument encodeDocument(Message source) { System.String messageClassName = source.GetType().FullName; System.String messageName = messageClassName.Substring(messageClassName.LastIndexOf('.') + 1); System.Xml.XmlDocument doc = null; try { doc = new System.Xml.XmlDocument(); System.Xml.XmlElement root = doc.CreateElement(messageName); doc.AppendChild(root); } catch (System.Exception e) { throw new NuGenHL7Exception("Can't create XML document - " + e.GetType().FullName, NuGenHL7Exception.APPLICATION_INTERNAL_ERROR, e); } encode(source, (System.Xml.XmlElement) doc.DocumentElement); return doc; }
/// <summary> Creates a PT.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public PT(Message message):base(message) { data = new Type[2]; data[0] = new ID(message, 0); data[1] = new ID(message, 0); }
/// <summary> Creates a XAD.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public XAD(Message message):base(message) { data = new Type[14]; data[0] = new SAD(message); data[1] = new ST(message); data[2] = new ST(message); data[3] = new ST(message); data[4] = new ST(message); data[5] = new ID(message, 399); data[6] = new ID(message, 190); data[7] = new ST(message); data[8] = new IS(message, 289); data[9] = new IS(message, 288); data[10] = new ID(message, 465); data[11] = new DR(message); data[12] = new TS(message); data[13] = new TS(message); }
/// <summary> Creates a WVS.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public WVS(Message message):base(message) { data = new Type[2]; data[0] = new ST(message); data[1] = new ST(message); }
/// <param name="theMessage">message to which this Type belongs /// </param> public TSComponentOne(Message theMessage):base(theMessage) { }
/// <summary> Creates a DR.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public DR(Message message):base(message) { data = new Type[2]; data[0] = new TS(message); data[1] = new TS(message); }
/// <summary> Creates a VH.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public VH(Message message):base(message) { data = new Type[4]; data[0] = new ID(message, 0); data[1] = new ID(message, 0); data[2] = new TM(message); data[3] = new TM(message); }
/// <param name="theMessage">message to which this Type belongs /// </param> public TM(Message theMessage):base(theMessage) { }
/// <summary> Constructs an uninitialized FT.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public FT(Message message):base(message) { }
/// <summary> Creates a HD.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public HD(Message message):base(message) { data = new Type[3]; data[0] = new IS(message, 300); data[1] = new ST(message); data[2] = new ID(message, 301); }
/// <summary> Creates a CM_OSP.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CM_OSP(Message message):base(message) { data = new Type[3]; data[0] = new ID(message, 0); data[1] = new DT(message); data[2] = new DT(message); }
/// <param name="theMessage">message to which this Type belongs /// </param> /// <param name="theTable">HL7 table from which values are to be drawn /// </param> public ID(Message theMessage, int theTable):base(theMessage, theTable) { }
/// <summary> Creates a CP.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CP(Message message):base(message) { data = new Type[6]; data[0] = new MO(message); data[1] = new ID(message, 205); data[2] = new NM(message); data[3] = new NM(message); data[4] = new CE(message); data[5] = new ID(message, 298); }
/// <summary> Creates a CM_FINANCE.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public CM_FINANCE(Message message):base(message) { data = new Type[2]; data[0] = new ID(message, 0); data[1] = new TS(message); }
/// <param name="theMessage">message to which this Type belongs /// </param> /// <param name="theTable">HL7 table from which values are to be drawn /// </param> public ID(Message theMessage, ref System.Int32 theTable):base(theMessage, ref theTable) { }
/// <summary> Creates a SPS.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public SPS(Message message):base(message) { data = new Type[7]; data[0] = new CE(message); data[1] = new TX(message); data[2] = new TX(message); data[3] = new CE(message); data[4] = new CE(message); data[5] = new CE(message); data[6] = new CE(message); }
/// <summary> Creates a VID.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public VID(Message message):base(message) { data = new Type[3]; data[0] = new ID(message, 0); data[1] = new CE(message); data[2] = new CE(message); }
/// <summary> Creates a RCD.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public RCD(Message message):base(message) { data = new Type[3]; data[0] = new ST(message); data[1] = new ST(message); data[2] = new NM(message); }
/// <summary> Creates a AD.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public AD(Message message):base(message) { data = new Type[8]; data[0] = new ST(message); data[1] = new ST(message); data[2] = new ST(message); data[3] = new ST(message); data[4] = new ST(message); data[5] = new ID(message, 399); data[6] = new ID(message, 190); data[7] = new ST(message); }
/// <summary> Creates a XON.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public XON(Message message):base(message) { data = new Type[9]; data[0] = new ST(message); data[1] = new IS(message, 0); data[2] = new NM(message); data[3] = new ST(message); data[4] = new ID(message, 0); data[5] = new HD(message); data[6] = new IS(message, 0); data[7] = new HD(message); data[8] = new ID(message, 0); }
/// <summary> Creates a OSD.</summary> /// <param name="message">the Message to which this Type belongs /// </param> public OSD(Message message):base(message) { data = new Type[11]; data[0] = new ID(message, 0); data[1] = new ST(message); data[2] = new IS(message, 0); data[3] = new ST(message); data[4] = new IS(message, 0); data[5] = new ST(message); data[6] = new NM(message); data[7] = new ST(message); data[8] = new ID(message, 0); data[9] = new ST(message); data[10] = new ID(message, 0); }