/// <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);
}
