private static CAttribute Map(this C_ATTRIBUTE model)
{
CAttribute attribute;
if (model is C_SINGLE_ATTRIBUTE)
{
attribute = new CSingleAttribute();
}
else if (model is C_MULTIPLE_ATTRIBUTE)
{
attribute = new CMultipleAttribute();
((CMultipleAttribute)attribute).Cardinality = ((C_MULTIPLE_ATTRIBUTE)model).cardinality.Map();
}
else
{
throw new ParseException(string.Format("'{0}' is not a valid attribute type.", model.GetType()));
}
attribute.Existence = model.existence.Map();
attribute.ReferenceModelAttributeName = model.rm_attribute_name;
if (model.children != null)
{
foreach (C_OBJECT child in model.children)
{
attribute.Children.Add(child.Map(attribute));
}
}
return(attribute);
}
protected override void SetAttributeValue(string attributeName, object value)
{
// Set Constraint
if (value != null && HasConstraint)
{
CAttribute attributeConstraint = Constraint.GetAttribute(attributeName);
if (attributeConstraint != null)
{
CMultipleAttribute multipleAttributeConstraint = attributeConstraint as CMultipleAttribute;
if (multipleAttributeConstraint != null)
{
IAggregate aggregate = value as IAggregate;
Check.Assert(aggregate != null, "value must implement IAggregate when attribute constraint is CMultipleAttribute");
aggregate.Constraint = multipleAttributeConstraint;
}
else
{
bool isValid = false;
foreach (CObject objectConstraint in attributeConstraint.Children)
{
if (objectConstraint.ValidValue(value))
{
isValid = true;
IRmType rmType = value as IRmType;
if (rmType != null)
{
rmType.Constraint = objectConstraint;
}
break;
}
}
}
}
}
}
protected void Validate(CMultipleAttribute cMultipleAttribute)
{
this.ValidateBase((CAttribute)cMultipleAttribute);
Invariant(cMultipleAttribute.Cardinality != null, string.Format(
CommonStrings.XMustNotBeNull, "CMultipleAttribute.Cardinality"));
this.Validate(cMultipleAttribute.Cardinality);
if (cMultipleAttribute.Members() != null)
{
foreach (CObject member in cMultipleAttribute.Members())
{
Invariant(member.Occurrences.Upper <= 1,
AmValidationStrings.MultiAttributeMembersBad);
}
}
}
internal static CAttribute CAttribute(string typeName)
{
DesignByContract.Check.Require(!string.IsNullOrEmpty(typeName), string.Format(CommonStrings.XMustNotBeNullOrEmpty, "typeName"));
CAttribute cAttribute = null;
switch (typeName)
{
case "C_SINGLE_ATTRIBUTE":
cAttribute = new CSingleAttribute();
break;
case "C_MULTIPLE_ATTRIBUTE":
cAttribute = new CMultipleAttribute();
break;
default:
throw new NotSupportedException("type not supported: " + typeName);
}
DesignByContract.Check.Ensure(cAttribute!= null, "cAttribute must not be null.");
return cAttribute;
}
void ReadCMultipleAttribute(XmlReader reader, CMultipleAttribute cMultipleAttribute)
{
Check.Require(cMultipleAttribute != null, string.Format(CommonStrings.XMustNotBeNull, "cMultipleAttribute"));
reader.ReadStartElement();
reader.MoveToContent();
ReadCAttribute(reader, cMultipleAttribute);
if (reader.LocalName != "cardinality")
{
throw new InvalidXmlException("cardinality" + reader.LocalName);
}
cMultipleAttribute.Cardinality = new Cardinality();
amSerializer.ReadCardinality(reader, cMultipleAttribute.Cardinality);
DesignByContract.Check.Assert(reader.NodeType == System.Xml.XmlNodeType.EndElement,
"Expected endElement");
reader.ReadEndElement();
reader.MoveToContent();
}
internal static CAttribute CAttribute(string typeName)
{
DesignByContract.Check.Require(!string.IsNullOrEmpty(typeName), string.Format(CommonStrings.XMustNotBeNullOrEmpty, "typeName"));
CAttribute cAttribute = null;
switch (typeName)
{
case "C_SINGLE_ATTRIBUTE":
cAttribute = new CSingleAttribute();
break;
case "C_MULTIPLE_ATTRIBUTE":
cAttribute = new CMultipleAttribute();
break;
default:
throw new NotSupportedException("type not supported: " + typeName);
}
DesignByContract.Check.Ensure(cAttribute != null, "cAttribute must not be null.");
return(cAttribute);
}
void ReadCComplexObject(XmlReader reader, AM.Archetype.ConstraintModel.CComplexObject cComplexObject)
{
Check.Require(cComplexObject != null, string.Format(CommonStrings.XMustNotBeNull, "cComplexObject"));
reader.ReadStartElement();
reader.MoveToContent();
amSerializer.ReadComplexObject(reader, cComplexObject);
if (reader.LocalName == "attributes")
{
System.Collections.Generic.List <CAttribute> attrList = new System.Collections.Generic.List <CAttribute>();
do
{
string attributeType = reader.GetAttribute("type", RmXmlSerializer.XsiNamespace);
DesignByContract.Check.Assert(!string.IsNullOrEmpty(attributeType), "attributeType must not be null or empty.");
CAttribute attri = AmFactory.CAttribute(attributeType);
attri.parent = cComplexObject;
CMultipleAttribute multipleAttribute = attri as CMultipleAttribute;
if (multipleAttribute != null)
{
ReadCMultipleAttribute(reader, multipleAttribute);
}
else
{
ReadCSingleAttribute(reader, attri as CSingleAttribute);
}
//Special attention being paid to media types due to erronous codes in archetypes produced by AE
// %HYYKA%
// TODO: this must be reinstated when ConfigurationSource is able to be specified
//if (attri.RmAttributeName == "media_type")
// ProcessMediaType(attri as CSingleAttribute);
attrList.Add(attri);
} while (reader.LocalName == "attributes" && reader.NodeType != XmlNodeType.EndElement);
if (cComplexObject.RmTypeName == "ITEM_TABLE")
{
//remove spurious attributes
for (int i = attrList.Count - 1; i >= 0; i--)
{
string rmAttributeName = attrList[i].RmAttributeName;
if (rmAttributeName == "rotated" || rmAttributeName == "number_key_columns")
{
attrList.RemoveAt(i);
}
}
}
Check.Assert(attrList.Count > 0, "attrList must not be empty.");
cComplexObject.Attributes = new OpenEhr.AssumedTypes.Set <CAttribute>(attrList);
}
if (reader.NodeType == System.Xml.XmlNodeType.EndElement)
{
reader.ReadEndElement();
reader.MoveToContent();
}
}
protected void BuildPath(Path path)
{
Check.Require(path != null, "path must not be null");
Check.Require(path.Current != null, "current path step must not be null");
string attributeName = path.Current.Attribute;
object value = GetAttributeValue(attributeName);
if (value == null)
{
CComplexObject complexObjectConstraint = this.Constraint as CComplexObject;
if (complexObjectConstraint == null)
{
throw new NotImplementedException();
}
CAttribute attributeConstraint = complexObjectConstraint.GetAttribute(attributeName);
if (attributeConstraint == null)
{
throw new ApplicationException("constraint for attribute not found");
}
CMultipleAttribute multipleAttributeConstraint = attributeConstraint as CMultipleAttribute;
if (multipleAttributeConstraint == null)
{
if (attributeConstraint.Children.Count != 1)
{
throw new ApplicationException("Single attribute constraint must have exactly one children");
}
CObject objectConstraint = attributeConstraint.Children[0];
CDefinedObject definedObjectConstraint = objectConstraint as CDefinedObject;
if (definedObjectConstraint == null)
{
throw new NotImplementedException();
}
value = definedObjectConstraint.DefaultValue;
SetAttributeValue(attributeName, value);
}
else
{
Type itemType = null;
value = multipleAttributeConstraint.CreateAggregate(itemType);
SetAttributeValue(attributeName, value);
}
}
if (path.NextStep())
{
IRmType rmType = value as IRmType;
if (rmType == null)
{
AssumedTypes.IAggregate container = value as AssumedTypes.IAggregate;
if (container != null)
{
container.BuildPath(path);
}
else
{
throw new ApplicationException("expected IRmType");
}
}
else
{
rmType.BuildPath(path);
}
}
}
protected void Validate(CMultipleAttribute cMultipleAttribute)
{
this.ValidateBase((CAttribute)cMultipleAttribute);
Invariant(cMultipleAttribute.Cardinality != null, string.Format(
CommonStrings.XMustNotBeNull, "CMultipleAttribute.Cardinality"));
this.Validate(cMultipleAttribute.Cardinality);
if (cMultipleAttribute.Members() != null)
{
foreach (CObject member in cMultipleAttribute.Members())
Invariant(member.Occurrences.Upper <= 1,
AmValidationStrings.MultiAttributeMembersBad);
}
}
public void IsValidThrowsException()
{
var instance = new CMultipleAttribute();
var result = instance.IsValid();
}
public void IsSubsetOfThrowsException()
{
var instance = new CMultipleAttribute();
var result = instance.IsSubsetOf(null);
}
public void ListsAreNotNull()
{
var instance = new CMultipleAttribute();
Assert.IsNotNull(instance.Members);
}
private void ReadXml(CMultipleAttribute cMultipleAttribute)
{
Check.Require(cMultipleAttribute != null, string.Format(CommonStrings.XMustNotBeNull, "cMultipleAttribute"));
reader.ReadStartElement();
reader.MoveToContent();
this.ReadXmlBase((CAttribute)cMultipleAttribute);
if (reader.LocalName != "cardinality")
throw new InvalidXmlException("cardinality" + reader.LocalName);
cMultipleAttribute.Cardinality = new Cardinality();
this.ReadXml(cMultipleAttribute.Cardinality);
DesignByContract.Check.Assert(reader.NodeType == System.Xml.XmlNodeType.EndElement, "Expected endElement");
reader.ReadEndElement();
reader.MoveToContent();
}
private void WriteXml(CMultipleAttribute cMultipleAttribute)
{
this.WriteXmlBase((CAttribute)cMultipleAttribute);
writer.WriteStartElement(UseOpenEhrPrefix(writer), "cardinality", RmXmlSerializer.OpenEhrNamespace);
this.WriteXml(cMultipleAttribute.Cardinality);
writer.WriteEndElement();
}
