// this case shouldn't happen, but is useful when the code is
// translated
/// <exception cref="System.Exception"></exception>
private void AssertParserIsRegistered(Type classObj)
{
IList <string> keys = ParserR2Registry.GetInstance().GetRegistrationKey(classObj);
foreach (string @string in keys)
{
Assert.IsNotNull(ParserR2Registry.GetInstance().Get(@string), "register " + classObj.FullName + " (" + @string + ")");
}
}
public virtual void TestParse()
{
XmlNode node = CreateNode("<top>" + "<something>Fred</something>" + "<something>Wilma</something>" + "<something>Betty</something>"
+ "</top>");
BareANY result = new SetR2ElementParser(ParserR2Registry.GetInstance()).Parse(ParseContextImpl.Create("SET<ST>", null, SpecificationVersion
.V02R02, null, null, Ca.Infoway.Messagebuilder.Xml.ConformanceLevel.MANDATORY, Cardinality.Create("1-5"), null, false),
AsList(node.ChildNodes), null);
ICollection <string> set = ((SET <ST, string>)result).RawSet();
Assert.IsNotNull(set, "null");
Assert.AreEqual(3, set.Count, "size");
Assert.IsTrue(set.Contains("Fred"), "Fred");
Assert.IsTrue(set.Contains("Wilma"), "Wilma");
Assert.IsTrue(set.Contains("Betty"), "Betty");
}
private object DelegateToConcreteParser(ParseContext context, XmlNode node, BareANY hl7Result, XmlToModelResult xmlToModelResult
)
{
object result = null;
string parentType = context == null ? null : context.Type;
string actualType = ObtainActualType(parentType, node, xmlToModelResult);
if (StringUtils.IsNotBlank(actualType))
{
ElementParser elementParser = ParserR2Registry.GetInstance().Get(actualType);
if (elementParser == null || !IsValidTypeForAny(parentType, actualType))
{
xmlToModelResult.AddHl7Error(Hl7Error.CreateInvalidTypeError(actualType, parentType, (XmlElement)node));
}
else
{
BareANY parsedValue = elementParser.Parse(ParseContextImpl.CreateWithConstraints(actualType, DetermineReturnType(actualType
, GetReturnType(context)), context), Arrays.AsList(node), xmlToModelResult);
result = parsedValue.BareValue;
// Yes, this is a side effect of calling this method. If we don't do this then the actual type of the ANY could be lost
hl7Result.DataType = parsedValue.DataType;
hl7Result.NullFlavor = parsedValue.NullFlavor;
// preserve all metadata (yes, also not a great side effect); this will have to be adjusted whenever new metadata is added to a data type (extremely infrequently)
if (hl7Result is ANYMetaData && parsedValue is ANYMetaData)
{
ANYMetaData anyMetaDataResult = (ANYMetaData)hl7Result;
ANYMetaData anyMetaDataParsed = (ANYMetaData)parsedValue;
anyMetaDataResult.Language = anyMetaDataParsed.Language;
anyMetaDataResult.DisplayName = anyMetaDataParsed.DisplayName;
anyMetaDataResult.OriginalText = anyMetaDataParsed.OriginalText;
anyMetaDataResult.Translations.AddAll(anyMetaDataParsed.Translations);
anyMetaDataResult.IsCdata = anyMetaDataParsed.IsCdata;
anyMetaDataResult.Operator = anyMetaDataParsed.Operator;
anyMetaDataResult.Unsorted = anyMetaDataParsed.Unsorted;
}
}
}
else
{
xmlToModelResult.AddHl7Error(Hl7Error.CreateMissingMandatoryAttributeError("xsi:type", (XmlElement)node));
}
return(result);
}
private Diff <PlatformDate> CreateDateDiff(ParseContext context, XmlElement width, XmlToModelResult xmlToModelResult)
{
Diff <PlatformDate> result = null;
if (GetAttributeValue(width, NullFlavorHelper.NULL_FLAVOR_ATTRIBUTE_NAME) != null)
{
result = ParseNullWidthNode(width);
}
else
{
try
{
StandardDataType diffType = StandardDataType.PQ;
ElementParser parser = ParserR2Registry.GetInstance().Get(diffType);
if (parser != null)
{
ParseContext subContext = ParseContextImpl.Create(diffType.Type, typeof(PhysicalQuantity), Ca.Infoway.Messagebuilder.Xml.ConformanceLevel
.POPULATED, Cardinality.Create("1"), context);
PhysicalQuantity quantity = (PhysicalQuantity)parser.Parse(subContext, Arrays.AsList((XmlNode)width), xmlToModelResult).BareValue;
// though in some PQ cases units can be null, this situation does not seem to make sense for PQ.TIME
if (quantity != null && quantity.Quantity != null && quantity.Unit != null)
{
result = new DateDiff(quantity);
}
}
else
{
xmlToModelResult.AddHl7Error(new Hl7Error(Hl7ErrorCode.DATA_TYPE_ERROR, "Cannot find a parser for " + diffType.Type, width
));
}
}
catch (XmlToModelTransformationException e)
{
xmlToModelResult.AddHl7Error(new Hl7Error(Hl7ErrorCode.DATA_TYPE_ERROR, e.Message, width));
}
}
return(result);
}
private BareANY CreateType(ParseContext context, XmlElement element, XmlToModelResult parseResult, bool isSxcm)
{
string type = GetParameterizedType(context);
if (isSxcm)
{
type = "SXCM<" + type + ">";
}
ElementParser parser = ParserR2Registry.GetInstance().Get(type);
if (parser != null)
{
ParseContext newContext = ParseContextImpl.CreateWithConstraints(type, context);
BareANY parsedValue = parser.Parse(newContext, Arrays.AsList((XmlNode)element), parseResult);
return(parsedValue);
}
else
{
parseResult.AddHl7Error(new Hl7Error(Hl7ErrorCode.DATA_TYPE_ERROR, System.String.Format("Cannot find a parser for type {0}"
, type), element));
return(null);
}
}
public SetR2ElementParser(ParserR2Registry parserRegistry) : base(parserRegistry, true)
{
}
public virtual void TestShouldFindSimpleCaseSt()
{
Assert.IsNotNull(ParserR2Registry.GetInstance().Get("ST"), "ST");
}
