public virtual void TestAdaptValueEventRelatedPeriodicInterval()
{
ANYImpl <EventRelatedPeriodicIntervalTime> original = new ANYImpl <EventRelatedPeriodicIntervalTime>();
original.Value = new EventRelatedPeriodicIntervalTime();
original.NullFlavor = Ca.Infoway.Messagebuilder.Domainvalue.Nullflavor.NullFlavor.NO_INFORMATION;
original.DataType = StandardDataType.IVL_TS;
original.Language = "Fr";
original.DisplayName = "Display Name";
original.Translations.Add(new CDImpl(Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive.CUP));
original.Translations.Add(new CDImpl(Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive.GALLON));
original.OriginalText = "Original Text";
original.IsCdata = false;
original.Unsorted = true;
original.Operator = SetOperator.CONVEX_HULL;
BareANY adaptedValue = GenericClassUtil.AdaptValue(original);
Assert.IsTrue(adaptedValue is SXCM_R2Impl <MbDate>);
SXCM_R2Impl <MbDate> actualValue = (SXCM_R2Impl <MbDate>)adaptedValue;
Assert.AreSame(original.Value, actualValue.Value);
Assert.AreSame(original.NullFlavor, actualValue.NullFlavor);
Assert.AreSame(original.DataType, actualValue.DataType);
Assert.AreSame(original.Language, actualValue.Language);
Assert.AreSame(original.DisplayName, actualValue.DisplayName);
Assert.AreSame(original.OriginalText, actualValue.OriginalText);
Assert.AreEqual(original.IsCdata, actualValue.IsCdata);
Assert.AreEqual(original.Unsorted, actualValue.Unsorted);
Assert.AreEqual(original.Operator, actualValue.Operator);
AssertTranslations(original.Translations, actualValue.Translations);
}
public virtual void TestCastDateIntervalCorrectType()
{
object expected = new Interval <PlatformDate>(new PlatformDate(), SetOperator.CONVEX_HULL);
object actual = GenericClassUtil.CastBareValueAsIntervalDate(expected);
Assert.AreSame(expected, actual);
}
/// <summary>Instantiate a bean that models the part under question.</summary>
/// <remarks>Instantiate a bean that models the part under question.</remarks>
/// <param name="version">- the version code</param>
/// <param name="type">- the part type</param>
/// <returns>an instance of a bean that represents the part type</returns>
public virtual object InstantiateMessagePartBean(VersionNumber version, string type, Interaction interaction)
{
try
{
Type partClass = MessageBeanRegistry.GetInstance().GetMessagePartClass(version, type);
if (partClass == null)
{
throw CreateMarshallingException("Did not find", version, type);
}
else
{
if (!ClassUtil.IsGeneric(partClass))
{
this.log.Debug("Instantiating bean: " + partClass.FullName);
return(System.Activator.CreateInstance(partClass));
}
else
{
this.log.Debug("Instantiating parameterized bean: " + partClass.FullName);
return(GenericClassUtil.Instantiate(partClass, CreateParameterMap(interaction, version)));
}
}
}
catch (MemberAccessException e)
{
throw CreateMarshallingException("Error instantiating", version, type, e);
}
catch (Exception e)
{
throw CreateMarshallingException("Error instantiating", version, type, e);
}
}
private void SetValue(BeanProperty property, object value)
{
if (value == null)
{
}
else
{
// do nothing
if (typeof(ICollection <object>).IsAssignableFrom(value.GetType()) && property.Collection)
{
foreach (object o in ((ICollection <object>)value))
{
Type clazz = GenericClassUtil.GetCollectionContentsType(property);
if (clazz == null || clazz.IsAssignableFrom(o.GetType()))
{
((ICollection <object>)property.Get()).Add(o);
}
else
{
object newInstance = ClassUtil.NewInstance(clazz);
AssignAllDefaults(newInstance, o);
((ICollection <object>)property.Get()).Add(newInstance);
}
}
}
else
{
if (property.Collection)
{
((ICollection <object>)property.Get()).Add(value);
}
else
{
if (typeof(ICollection <object>).IsAssignableFrom(value.GetType()))
{
foreach (object o in ((ICollection <object>)value))
{
property.Set(o);
}
}
else
{
if (!IsStandardDataType(property))
{
CreateBeanInstanceForProperty(property);
AssignAllDefaults(property.Get(), value);
}
else
{
if (property.Writable)
{
property.Set(value);
}
}
}
}
}
}
}
public virtual void TestGetValueFromANYNullValue()
{
CD_R2 <UnitsOfMeasureCaseSensitive> anyValue = CreateCDR2Instance();
anyValue.Value = null;
Assert.AreEqual(anyValue.Value, GenericClassUtil.GetValueFromANY(anyValue));
}
public void ShouldInstantiateListFromDictionary()
{
Type t = typeof(List <>);
IDictionary <String, Type> dictionary = new Dictionary <String, Type>();
dictionary.Add("T", typeof(String));
Object o = GenericClassUtil.Instantiate(typeof(List <>), dictionary);
Assert.AreEqual("System.Collections.Generic.List`1[System.String]", o.GetType().ToString(), "type");
}
// constraints are not passed down from collection attributes
public override string Format(FormatContext context, BareANY hl7Value, int indentLevel)
{
if (hl7Value == null)
{
return(string.Empty);
}
ICollection <BareANY> bareAnyCollection = GenericClassUtil.ConvertToBareANYCollection(hl7Value);
HandleConstraints(GetSubType(context), context.GetConstraints(), hl7Value, bareAnyCollection, context);
return(base.Format(context, hl7Value, indentLevel));
}
public void ShouldInstantiateListOfLists()
{
List <TemplateArgument> arguments = new List <TemplateArgument>();
List <TemplateArgument> subArguments = new List <TemplateArgument>();
subArguments.Add(new TemplateArgument(typeof(String), new List <TemplateArgument>()));
arguments.Add(new TemplateArgument(typeof(List <>), subArguments));
Object o = GenericClassUtil.Instantiate(typeof(List <>), arguments);
Assert.AreEqual("System.Collections.Generic.List`1[System.Collections.Generic.List`1[System.String]]", o.GetType().ToString(), "type");
}
private BareANY ConvertDataType(BareANY dataType)
{
object bareValue = dataType.BareValue;
Interval <PlatformDate> ivlTsR1 = GenericClassUtil.CastBareValueAsIntervalDate(bareValue);
DateInterval ivlTsR2 = (ivlTsR1 == null ? null : ConvertIvlTs(ivlTsR1));
IVLTSCDAR1 result = new IVLTSCDAR1Impl();
result.DataType = dataType.DataType;
result.BareValue = ivlTsR2;
result.NullFlavor = dataType.NullFlavor;
return(result);
}
public void ShouldInstantiateList()
{
Type t = typeof(List <>);
foreach (Type argument in t.GetGenericArguments())
{
Console.WriteLine(argument.Name);
}
List <TemplateArgument> arguments = new List <TemplateArgument>();
arguments.Add(new TemplateArgument(typeof(String), new List <TemplateArgument>()));
Object o = GenericClassUtil.Instantiate(typeof(List <>), arguments);
Assert.AreEqual("System.Collections.Generic.List`1[System.String]", o.GetType().ToString(), "type");
}
/// <exception cref="Ca.Infoway.Messagebuilder.Marshalling.HL7.XmlToModelTransformationException"></exception>
public virtual BareANY Parse(ParseContext context, IList <XmlNode> nodes, XmlToModelResult xmlToModelResult)
{
BareANY parsedValue = actualIvlTsParser.Parse(context, nodes, xmlToModelResult);
// need to wrap result in a DateInterval
object bareValue = parsedValue.BareValue;
Interval <PlatformDate> interval = GenericClassUtil.CastBareValueAsIntervalDate(bareValue);
if (interval != null)
{
DateInterval newValue = new DateInterval(interval);
XmlNode node = (nodes == null || nodes.Count == 0 ? null : nodes[0]);
// should always have a node
HandleConstraints(context, xmlToModelResult, (XmlElement)node, newValue);
//Have to create a new value since .NET won't allow re-assign of BareValue
return(createNewParsedValue((IVLImpl <QTY <PlatformDate>, Interval <PlatformDate> >)parsedValue, newValue));
}
return(parsedValue);
}
protected override BareANY WrapWithHl7DataType(string type, string subType, ICollection <BareANY> collection, ParseContext
context)
{
CollectionHelper result = CreateCollectionHelper(type, context.GetExpectedReturnType());
bool adaptValue = AdaptValue(type);
foreach (BareANY bareANY in collection)
{
if (adaptValue)
{
BareANY adaptedValue = GenericClassUtil.AdaptValue(bareANY);
result.Add(adaptedValue);
}
else
{
result.Add(bareANY);
}
}
return((BareANY)result);
}
private CD ConvertAnyToCd(BareANY hl7Value)
{
ANYMetaData anyCd = (ANYMetaData)hl7Value;
CD cd = new CDImpl();
if (anyCd != null)
{
if (GenericClassUtil.IsInstanceOfANY(hl7Value))
{
object value = GenericClassUtil.GetValueFromANY(hl7Value);
if (value is Code)
{
cd.Value = (Code)value;
}
}
cd.DataType = hl7Value.DataType;
cd.NullFlavor = hl7Value.NullFlavor;
cd.DisplayName = anyCd.DisplayName;
cd.OriginalText = anyCd.OriginalText;
cd.Translations.AddAll(anyCd.Translations);
}
return(cd);
}
public virtual void TestConvertToBareANYCollectionType()
{
var first = new CodedTypeR2 <UnitsOfMeasureCaseSensitive>(Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive.CUP);
var second = new CodedTypeR2 <UnitsOfMeasureCaseSensitive>(Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive.DECALITRE);
var third = new CodedTypeR2 <UnitsOfMeasureCaseSensitive>(Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive.GALLON);
LIST <CD_R2 <UnitsOfMeasureCaseSensitive>, CodedTypeR2 <UnitsOfMeasureCaseSensitive> > list =
new LISTImpl <CD_R2 <UnitsOfMeasureCaseSensitive>, CodedTypeR2 <UnitsOfMeasureCaseSensitive> >(typeof(CD_R2Impl <UnitsOfMeasureCaseSensitive>));
list.RawList().Add(first);
list.RawList().Add(second);
list.RawList().Add(third);
ICollection <BareANY> bareANYCollection = GenericClassUtil.ConvertToBareANYCollection(list);
IEnumerator <BareANY> enumerator = bareANYCollection.GetEnumerator();
enumerator.MoveNext();
Assert.AreSame(first, enumerator.Current.BareValue);
enumerator.MoveNext();
Assert.AreSame(second, enumerator.Current.BareValue);
enumerator.MoveNext();
Assert.AreSame(third, enumerator.Current.BareValue);
}
public virtual void TestIsInstanceofANYTrue()
{
Assert.IsTrue(GenericClassUtil.IsInstanceOfANY(new CD_R2Impl <Code>()));
}
public virtual void TestCastDateIntervalWrongType()
{
Assert.IsNull(GenericClassUtil.CastBareValueAsIntervalDate("abcd"));
Assert.IsNull(GenericClassUtil.CastBareValueAsIntervalDate(new Interval <string>("abcd", SetOperator.CONVEX_HULL)));
}
private CollectionHelper HandleListTypes(string typeName, Type expectedReturnType)
{
if ("LIST<AD>".Equals(typeName))
{
return(new LISTImpl <AD, PostalAddress>(typeof(ADImpl)));
}
else
{
if ("LIST<GTS>".Equals(typeName))
{
return(new LISTImpl <GTS, GeneralTimingSpecification>(typeof(GTSImpl)));
}
else
{
if ("LIST<II>".Equals(typeName))
{
return(new LISTImpl <II, Identifier>(typeof(IIImpl)));
}
else
{
if ("LIST<PN>".Equals(typeName))
{
return(new LISTImpl <PN, PersonName>(typeof(PNImpl)));
}
else
{
if ("LIST<TEL>".Equals(typeName))
{
return(new LISTImpl <TEL, TelecommunicationAddress>(typeof(TELImpl)));
}
else
{
if ("LIST<ON>".Equals(typeName))
{
return(new LISTImpl <ON, OrganizationName>(typeof(ONImpl)));
}
else
{
if ("LIST<CD>".Equals(typeName))
{
return(CodedTypeR2Helper.CreateCDList(expectedReturnType));
}
else
{
if ("LIST<CS>".Equals(typeName))
{
return(CodedTypeR2Helper.CreateCSList(expectedReturnType));
}
else
{
if ("LIST<CE>".Equals(typeName))
{
return(CodedTypeR2Helper.CreateCEList(expectedReturnType));
}
else
{
if ("LIST<SXCM<TS>>".Equals(typeName))
{
return(GenericClassUtil.CreateSXCMR2List());
}
else
{
if ("LIST<ANY>".Equals(typeName))
{
return(new LISTImpl <ANY <object>, object>(typeof(ANYImpl <object>)));
}
else
{
if ("LIST<INT>".Equals(typeName))
{
return(new LISTImpl <INT, Int32?>(typeof(INTImpl)));
}
else
{
if ("LIST<PQ>".Equals(typeName))
{
return(new LISTImpl <PQ, PhysicalQuantity>(typeof(PQImpl)));
}
else
{
if ("LIST<ST>".Equals(typeName))
{
return(new LISTImpl <ST, string>(typeof(STImpl)));
}
else
{
if ("LIST<SXCMTSCDAR1>".Equals(typeName))
{
return(new LISTImpl <SXCMTSCDAR1, MbDate>(typeof(SXCMTSCDAR1Impl)));
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
return(null);
}
private void ValidateNonstructuralFixedValue(Relationship relationship, BareANY value, Hl7Source source, IList <XmlNode> nodes
)
{
if (relationship.HasFixedValue())
{
bool valueProvided = (value != null && value.BareValue != null);
bool valid = valueProvided || (!ConformanceLevelUtil.IsMandatory(relationship) && !ConformanceLevelUtil.IsPopulated(relationship
));
// optional and required fixed values do not have to provide a value, but if they do they must conform to specified value
if (valueProvided)
{
if ("BL".Equals(relationship.Type) && value is BL)
{
string valueAsString = ((BL)value).Value.ToString();
valid = relationship.FixedValue.EqualsIgnoreCase(valueAsString);
}
else
{
if ("ST".Equals(relationship.Type) && value is ST)
{
string valueAsString = ((ST)value).Value.ToString();
valid = relationship.FixedValue.EqualsIgnoreCase(valueAsString);
}
else
{
if ("INT.POS".Equals(relationship.Type) && value is INT)
{
string valueAsString = ((INT)value).Value.ToString();
valid = relationship.FixedValue.EqualsIgnoreCase(valueAsString);
}
else
{
if (relationship.CodedType)
{
if (source.IsR2())
{
if (GenericClassUtil.IsInstanceOfANY(value))
{
object value2 = GenericClassUtil.GetValueFromANY(value);
Code code = value2 == null ? null : CodedTypeR2Helper.GetCode(value2);
valid = (code != null && code.CodeValue != null && StringUtils.Equals(relationship.FixedValue, code.CodeValue));
}
}
else
{
if (value is CD)
{
Code code = ((CD)value).Value;
valid = (code.CodeValue != null && StringUtils.Equals(relationship.FixedValue, code.CodeValue));
}
}
}
else
{
source.GetResult().AddHl7Error(new Hl7Error(Hl7ErrorCode.SYNTAX_ERROR, "Non-structural fixed-value attribute '" + relationship
.Name + "' was of unexpected type '" + relationship.Type + "'", CollUtils.IsEmpty(nodes) ? null : (XmlElement)nodes[0]));
}
}
}
}
}
if (!valid)
{
source.GetResult().AddHl7Error(new Hl7Error(Hl7ErrorCode.MANDATORY_FIELD_NOT_PROVIDED, "Fixed-value attribute '" + relationship
.Name + "' must have value '" + relationship.FixedValue + "'", CollUtils.IsEmpty(nodes) ? null : (XmlElement)nodes[0]));
}
}
}
public virtual void TestConvertToBareANYNonCollectionType()
{
CD_R2 <UnitsOfMeasureCaseSensitive> anyValue = CreateCDR2Instance();
Assert.IsNull(GenericClassUtil.ConvertToBareANYCollection(anyValue));
}
public virtual void TestConvertToBareANYNullValue()
{
Assert.IsNull(GenericClassUtil.ConvertToBareANYCollection(null));
}
public virtual void TestAdaptValueAdaptNotRequired()
{
BareANY original = new CDImpl();
Assert.AreSame(original, GenericClassUtil.AdaptValue(original));
}
public virtual void TestGetValueFromANYWrongObject()
{
GenericClassUtil.GetValueFromANY("abcd");
}
public virtual void TestIsInstanceOfANYDifferentObject()
{
Assert.IsFalse(GenericClassUtil.IsInstanceOfANY("abcd"));
}
public virtual void TestIsInstanceOfANYNull()
{
Assert.IsFalse(GenericClassUtil.IsInstanceOfANY(null));
}
public void ShouldInstantiateNonGenericType()
{
Object o = GenericClassUtil.Instantiate(typeof(ArrayList), new List <TemplateArgument>());
Assert.AreEqual("System.Collections.ArrayList", o.GetType().ToString(), "type");
}
