/// <summary> Attempts to extract a Primitive from the given type. If it's a composite,
/// drills down through first components until a primitive is reached.
/// </summary>
private static Primitive getPrimitive(Genetibase.NuGenHL7.model.Type type)
{
Primitive p = null;
if (typeof(Varies).IsAssignableFrom(type.GetType()))
{
p = getPrimitive(((Varies)type).Data);
}
else if (typeof(Composite).IsAssignableFrom(type.GetType()))
{
try
{
p = getPrimitive(((Composite)type).getComponent(0));
}
catch (NuGenHL7Exception)
{
throw new System.ApplicationException("Internal error: HL7Exception thrown on Composite.getComponent(0).");
}
}
else if (type is Primitive)
{
p = (Primitive)type;
}
return(p);
}
/// <summary> Returns the component (or sub-component, as the case may be) at the given
/// index. If it does not exist, it is added as an "extra component".
/// If comp > 1 is requested from a Varies with GenericPrimitive data, the
/// data is set to GenericComposite (this avoids the creation of a chain of
/// ExtraComponents on GenericPrimitives).
/// Components are numbered from 1.
/// </summary>
private static Genetibase.NuGenHL7.model.Type getComponent(Genetibase.NuGenHL7.model.Type type, int comp)
{
Genetibase.NuGenHL7.model.Type ret = null;
if (typeof(Varies).IsAssignableFrom(type.GetType()))
{
Varies v = (Varies)type;
try
{
if (comp > 1 && typeof(GenericPrimitive).IsAssignableFrom(v.Data.GetType()))
{
v.Data = new GenericComposite(v.Message);
}
}
catch (DataTypeException de)
{
System.String message = "Unexpected exception copying data to generic composite: " + de.Message;
throw new System.ApplicationException(message);
}
ret = getComponent(v.Data, comp);
}
else
{
if (typeof(Primitive).IsAssignableFrom(type.GetType()) && comp == 1)
{
ret = type;
}
else if (typeof(GenericComposite).IsAssignableFrom(type.GetType()) || (typeof(Composite).IsAssignableFrom(type.GetType()) && comp <= numStandardComponents(type)))
{
//note that GenericComposite can return components > number of standard components
try
{
ret = ((Composite)type).getComponent(comp - 1);
}
catch (System.Exception e)
{
throw new Exception("Internal error: HL7Exception thrown on getComponent(x) where x < # standard components.", e);
}
}
else
{
ret = type.ExtraComponents.getComponent(comp - numStandardComponents(type) - 1);
}
}
return(ret);
}
public virtual NuGenHL7Exception[] testComponent(Genetibase.NuGenHL7.model.Type type, Component profile, System.String profileID)
{
System.Collections.ArrayList exList = new System.Collections.ArrayList(20);
addToList(testType(type, profile, null, profileID), exList);
//test children
if (profile.SubComponents > 0 && !profile.Usage.Equals("X") && hasContent(type))
{
if (typeof(Composite).IsAssignableFrom(type.GetType()))
{
Composite comp = (Composite)type;
for (int i = 1; i <= profile.SubComponents; i++)
{
SubComponent childProfile = profile.getSubComponent(i);
try
{
Genetibase.NuGenHL7.model.Type child = comp.getComponent(i - 1);
addToList(testType(child, childProfile, null, profileID), exList);
}
catch (DataTypeException de)
{
exList.Add(new NuGenProfileNotHL7CompliantException("More subcomponents in profile than allowed in message: " + de.Message));
}
}
addToList(checkExtraComponents(comp, profile.SubComponents), exList);
}
else
{
exList.Add(new NuGenProfileNotFollowedException("A component has primitive type " + type.GetType().FullName + " but the profile defines subcomponents"));
}
}
return(toArray(exList));
}
/// <summary> Returns the number of components in the given field, i.e. the
/// number of standard components (e.g. 6 for CE) plus any extra components that
/// have been added at runtime. This may vary by repetition, as different reps
/// may have different extra components.
/// </summary>
/*public static int numComponents(Type field) throws HL7Exception {
* return numComponents(seg.getField(field, rep));
* }*/
/// <summary> Returns the number of sub-components in the specified component, i.e.
/// the number of standard sub-components (e.g. 6 for CE) plus any extra components that
/// that have been added at runtime.
/// </summary>
/// <param name="component">numbered from 1
/// </param>
public static int numSubComponents(Genetibase.NuGenHL7.model.Type type, int component)
{
int n = -1;
if (component == 1 && typeof(Primitive).IsAssignableFrom(type.GetType()))
{
//note that getComponent(primitive, 1) below returns the primitive
//itself -- if we do numComponents on it, we'll end up with the
//number of components in the field, not the number of subcomponents
n = 1;
}
else
{
Genetibase.NuGenHL7.model.Type comp = getComponent(type, component);
n = numComponents(comp);
}
return(n);
/*
* //Type t = seg.getField(field, rep);
* if (Varies.class.isAssignableFrom(type.getClass())) {
* return numSubComponents(((Varies) type).getData(), component);
* } else if (Primitive.class.isAssignableFrom(type.getClass()) && component == 1) {
* n = 1;
* } else if (Composite.class.isAssignableFrom(type.getClass()) && component <= numStandardComponents(t)) {
* n = numComponents(((Composite) type).getComponent(component - 1));
* } else { //we're being asked about subcomponents of an extra component
* n = numComponents(t.getExtraComponents().getComponent(component - numStandardComponents(t) - 1));
* }
* return n;
*/
}
private static int numStandardComponents(Genetibase.NuGenHL7.model.Type t)
{
int n = 0;
if (typeof(Varies).IsAssignableFrom(t.GetType()))
{
n = numStandardComponents(((Varies)t).Data);
}
else if (typeof(Composite).IsAssignableFrom(t.GetType()))
{
n = ((Composite)t).Components.Length;
}
else
{
n = 1;
}
return(n);
}
public virtual NuGenHL7Exception[] testField(Genetibase.NuGenHL7.model.Type type, Field profile, bool escape, System.String profileID)
{
System.Collections.ArrayList exList = new System.Collections.ArrayList(20);
//account for MSH 1 & 2 which aren't escaped
System.String encoded = null;
if (!escape && typeof(Primitive).IsAssignableFrom(type.GetType()))
{
encoded = ((Primitive)type).Value;
}
addToList(testType(type, profile, encoded, profileID), exList);
//test children
if (profile.Components > 0 && !profile.Usage.Equals("X"))
{
if (typeof(Composite).IsAssignableFrom(type.GetType()))
{
Composite comp = (Composite)type;
for (int i = 1; i <= profile.Components; i++)
{
Component childProfile = profile.getComponent(i);
try
{
Genetibase.NuGenHL7.model.Type child = comp.getComponent(i - 1);
addToList(testComponent(child, childProfile, profileID), exList);
}
catch (DataTypeException de)
{
exList.Add(new NuGenProfileNotHL7CompliantException("More components in profile than allowed in message: " + de.Message));
}
}
addToList(checkExtraComponents(comp, profile.Components), exList);
}
else
{
exList.Add(new NuGenProfileNotHL7CompliantException("A field has type primitive " + type.GetType().FullName + " but the profile defines components"));
}
}
return(toArray(exList));
}
/// <summary> Returns the number of components in the given type, i.e. the
/// number of standard components (e.g. 6 for CE) plus any extra components that
/// have been added at runtime.
/// </summary>
public static int numComponents(Genetibase.NuGenHL7.model.Type type)
{
if (typeof(Varies).IsAssignableFrom(type.GetType()))
{
return(numComponents(((Varies)type).Data));
}
else
{
return(numStandardComponents(type) + type.ExtraComponents.numComponents());
}
}
/// <summary> Tests a Type against the corresponding section of a profile.</summary>
/// <param name="encoded">optional encoded form of type (if you want to specify this -- if null,
/// default pipe-encoded form is used to check length and constant val)
/// </param>
public virtual NuGenHL7Exception[] testType(Genetibase.NuGenHL7.model.Type type, AbstractComponent profile, System.String encoded, System.String profileID)
{
System.Collections.ArrayList exList = new System.Collections.ArrayList();
if (encoded == null)
{
encoded = NuGenPipeParser.encode(type, this.enc);
}
NuGenHL7Exception ue = testUsage(encoded, profile.Usage, profile.Name);
if (ue != null)
{
exList.Add(ue);
}
if (!profile.Usage.Equals("X"))
{
//check datatype
System.String typeClass = type.GetType().FullName;
if (typeClass.IndexOf("." + profile.Datatype) < 0)
{
typeClass = typeClass.Substring(typeClass.LastIndexOf('.') + 1);
exList.Add(new NuGenProfileNotHL7CompliantException("HL7 datatype " + typeClass + " doesn't match profile datatype " + profile.Datatype));
}
//check length
if (encoded.Length > profile.Length)
{
exList.Add(new NuGenProfileNotFollowedException("The type " + profile.Name + " has length " + encoded.Length + " which exceeds max of " + profile.Length));
}
//check constant value
if (profile.ConstantValue != null && profile.ConstantValue.Length > 0)
{
if (!encoded.Equals(profile.ConstantValue))
{
exList.Add(new NuGenProfileNotFollowedException("'" + encoded + "' doesn't equal constant value of '" + profile.ConstantValue + "'"));
}
}
NuGenHL7Exception[] te = testTypeAgainstTable(type, profile, profileID);
for (int i = 0; i < te.Length; i++)
{
exList.Add(te[i]);
}
}
return(this.toArray(exList));
}
