private int Position(AssertionContext contextObj)
{
DesignByContract.Check.Require(this.functionName.Equals("position", StringComparison.InvariantCultureIgnoreCase),
"functionName must be position");
AssertionContext parent = contextObj.Parent;
System.Collections.IList list = parent.Data as System.Collections.IList;
if (list != null)
{
return(list.IndexOf(contextObj.Data));
}
AssumedTypes.IList assumedList = parent.Data as AssumedTypes.IList;
if (assumedList != null)
{
for (int i = 0; i < assumedList.Count; i++)
{
if (contextObj.Data.Equals(assumedList[i]))
{
return(i + 1);
}
}
}
return(-1);
}
public override bool ValidValue(object dataValue)
{
Check.Require(dataValue != null, string.Format(CommonStrings.XMustNotBeNull, "dataValue"));
AssumedTypes.IAggregate aggregate = dataValue as AssumedTypes.IAggregate;
Check.Require(aggregate != null, string.Format(
AmValidationStrings.XMustImplementY, dataValue.GetType().ToString(), "IAggregate"));
bool result = true;
aggregate.Constraint = this;
AssumedTypes.IList iList = dataValue as AssumedTypes.IList;
if (iList == null)
{
throw new ApplicationException(string.Format(AmValidationStrings.XMustImplementY, dataValue.GetType().ToString(), "IList"));
}
if (!Cardinality.Interval.Has(iList.Count))
{
result = false;
ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.CardinalityOutOfBounds, iList.Count, RmAttributeName));
}
result &= Cardinality.IsOrdered ? IsOrderedChildrenValid(iList) : IsUnorderedChildrenValid(iList);
result &= IsOccurrencesValid(iList);
return(result);
}
public object ItemAtPath(object obj)
{
object itemAtPath = this.pathExpr.Evaluate(obj);
AssumedTypes.IList iList = itemAtPath as AssumedTypes.IList;
// if itemAtPath is not a list, return it.
if (iList == null)
{
return(itemAtPath);
}
//// if itemAtPath is a list, generate LocatableList when the items are locatable.
//// otherwise return the list
LocatableList <Locatable> locatableList = null;
AssumedTypes.List <object> items = iList as AssumedTypes.List <object>;
if (items != null)
{
return(items);
}
else
{
items = new OpenEhr.AssumedTypes.List <object>();
}
foreach (object o in iList)
{
items.Add(o);
}
return(items);
}
private object GetAttributeObject(string attributeName, AssumedTypes.IList list)
{
if (list == null || list.Count == 0)
{
return(null);
}
AssumedTypes.List <object> attrObjects = new OpenEhr.AssumedTypes.List <object>();
foreach (object obj in list)
{
object attributeObj = CallGetAttributeObject(attributeName, obj);
if (attributeObj != null)
{
attrObjects.Add(attributeObj);
}
}
if (attrObjects.Count > 1)
{
return(attrObjects);
}
if (attrObjects.Count == 1)
{
return(attrObjects[0]);
}
return(null);
}
public override object ItemAtPath(string path)
{
Check.Require(!string.IsNullOrEmpty(path), "Path must not be null or empty.");
object itemInDictionary = null;
Path pathObject = new Path(path);
if (itemInDictionary == null)
{
throw new PathNotExistException(path);
}
if (itemInDictionary is AssumedTypes.IList)
{
AssumedTypes.IList list = itemInDictionary as AssumedTypes.IList;
if (list.Count > 1)
{
throw new PathNotUniqueException(path);
}
else
{
return(list[0]);
}
}
else
{
return(itemInDictionary);
}
}
private bool IsOccurrencesValid(AssumedTypes.IList dataChildren)
{
Check.Require(dataChildren != null, string.Format(CommonStrings.XMustNotBeNull, "dataChildren"));
bool result = true;
System.Collections.Generic.List <MatchingItems> matches = new System.Collections.Generic.List <MatchingItems>();
AcceptValidationError previousErrorDelegate = ValidationContext.AcceptError;
try
{
ValidationContext.AcceptError = null;
foreach (CObject constraint in Children)
{
if (constraint.Occurrences.Lower > 0 || !constraint.Occurrences.UpperUnbounded)
{
matches.Add(new MatchingItems(dataChildren, constraint));
}
}
}
finally
{
ValidationContext.AcceptError = previousErrorDelegate;
}
foreach (MatchingItems match in matches)
{
match.RemoveItemsAlreadyMatchedByNameAndNodeId(matches);
CObject constraint = match.Constraint;
int lower = match.Lower;
long upper = match.Upper;
int actual = match.Count;
if (actual < lower)
{
result = false;
ValidationContext.AcceptValidationError(constraint, string.Format(AmValidationStrings.NotEnoughOccurrences, constraint.NodeId, lower, actual));
}
if (actual > upper)
{
result = false;
ValidationContext.AcceptValidationError(constraint, string.Format(AmValidationStrings.TooManyOccurrences, constraint.NodeId, upper, actual));
}
}
return(result);
}
public MatchingItems(AssumedTypes.IList dataChildren, CObject constraint) : base()
{
Check.Require(dataChildren != null, string.Format(CommonStrings.XMustNotBeNull, "dataChildren"));
Check.Require(constraint != null, string.Format(CommonStrings.XMustNotBeNull, "constraint"));
Constraint = constraint;
NameAttribute = NameAttributeConstraint(constraint);
Lower = constraint.Occurrences.Lower;
Upper = constraint.Occurrences.UpperUnbounded ? long.MaxValue : constraint.Occurrences.Upper;
CArchetypeRoot archetypeRoot = constraint as CArchetypeRoot;
NodeId = archetypeRoot != null ? archetypeRoot.ArchetypeId.Value : constraint.NodeId;
if (!(constraint is ArchetypeSlot))
{
OpenEhr.AssumedTypes.Impl.ILocatableList locatableItems = dataChildren as OpenEhr.AssumedTypes.Impl.ILocatableList;
if (locatableItems != null)
{
Check.Assert(!string.IsNullOrEmpty(NodeId), string.Format(CommonStrings.XMustNotBeNullOrEmpty, "NodeId"));
if (locatableItems.Contains(NodeId))
{
foreach (OpenEhr.RM.Common.Archetyped.Impl.Locatable locatable in (System.Collections.IEnumerable)locatableItems[NodeId])
{
if (NameAttribute == null || NameAttribute.ValidValue(locatable.Name))
{
Add(locatable);
}
}
}
}
else
{
foreach (object item in dataChildren)
{
IRmType rmType = item as IRmType;
if (rmType != null && constraint.IsSameRmType(rmType))
{
Add(item);
}
}
}
}
Check.Ensure(Constraint == constraint);
}
private object CallGetAttributeObject(string attributeName, object obj)
{
AttributeDictionaryPathable pathable = obj as AttributeDictionaryPathable;
if (pathable != null)
{
return(pathable.GetAttributeValue(attributeName));
}
AssumedTypes.IList assumedList = obj as AssumedTypes.IList;
if (assumedList != null)
{
return(GetAttributeObject(attributeName, assumedList));
}
System.Collections.IList list = obj as System.Collections.IList;
if (list != null)
{
return(GetAttributeObject(attributeName, list));
}
string openEhrV1AttributeName = GetOpenEhrV1AttributeName(attributeName, obj);
System.ComponentModel.PropertyDescriptorCollection propertyDescriptorCollection =
System.ComponentModel.TypeDescriptor.GetProperties(obj);
System.ComponentModel.PropertyDescriptor property =
propertyDescriptorCollection.Find(openEhrV1AttributeName, true);
if (property == null)
{
property = propertyDescriptorCollection.Find(attributeName, false);
}
if (property == null)
{
return(null);
}
object attributeObj = property.GetValue(obj);
return(attributeObj);
}
/// <summary>
/// An abstract function evaluating the obj against the ExprItem.
/// </summary>
/// <param name="obj">The object to be evaluated</param>
/// <returns>Can be an object, a list of object or boolean</returns>
internal object Evaluate(object obj)
{
OpenEhr.Paths.AssertionContext contextObj = new OpenEhr.Paths.AssertionContext(obj, null);
OpenEhr.Paths.AssertionContext returnedObject = Evaluate(contextObj);
if (returnedObject == null)
{
return(null);
}
object result = returnedObject.Data;
AssumedTypes.IList iList = result as AssumedTypes.IList;
if (iList != null && iList.Count == 1)
{
return(iList[0]);
}
return(result);
}
public override object ItemAtPath(string path)
{
DesignByContract.Check.Require(!string.IsNullOrEmpty(path), "Path must not be null or empty.");
object itemInDictionary = null;
if (this.itemAtPathDictionary != null && this.itemAtPathDictionary.ContainsKey(path))
{
itemInDictionary = itemAtPathDictionary[path];
}
else
{
itemInDictionary = ItemAtPathUtil(path);
}
if (itemInDictionary == null)
{
throw new PathNotExistException(path);
}
AssumedTypes.IList list = itemInDictionary as AssumedTypes.IList;
if (list != null)
{
if (list.Count > 1)
{
throw new PathNotUniqueException(path);
}
else
{
return(list[0]);
}
}
else
{
return(itemInDictionary);
}
}
private bool IsOrderedChildrenValid(AssumedTypes.IList dataChildren)
{
Check.Require(dataChildren != null, string.Format(CommonStrings.XMustNotBeNull, "children"));
int n = 0;
bool result = true;
foreach (object dataItem in dataChildren)
{
int startingPoint = n;
CObject matchedCObject = null;
string dataItemRmType = ((IRmType)dataItem).GetRmTypeName();
ILocatable locatable = dataItem as ILocatable;
while (n < Children.Count)
{
CObject eachChild = Children[n];
if (locatable == null || locatable.ArchetypeNodeId == eachChild.ArchetypeNodeId)
{
if (eachChild.IsSameRmType(dataItem as IRmType))
{
matchedCObject = eachChild;
CComplexObject complexObject = eachChild as CComplexObject;
if (complexObject != null)
{
CAttribute nameAttribute = NameAttributeConstraint(complexObject);
if (nameAttribute != null)
{
bool nameMatched = false;
AcceptValidationError previousErrorDelegate = ValidationContext.AcceptError;
try
{
ValidationContext.AcceptError = null;
nameMatched = nameAttribute.ValidValue(locatable.Name);
}
finally
{
ValidationContext.AcceptError = previousErrorDelegate;
}
if (nameMatched)
{
break;
}
else
{
n++;
continue;
}
}
}
break;
}
}
n++;
}
if (matchedCObject == null)
{
n = startingPoint;
bool validationResult = true;
if (MatchedWithSlot(locatable, out validationResult))
{
result = validationResult;
}
else
{
result = false;
ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.YNotAllowedByAttributeXConstraint, RmAttributeName, dataItemRmType));
}
}
else if (!matchedCObject.ValidValue(dataItem))
{
result = false;
}
}
return(result);
}
private bool IsUnorderedChildrenValid(AssumedTypes.IList dataChildren)
{
Check.Require(dataChildren != null, string.Format(CommonStrings.XMustNotBeNull, "children"));
bool result = true;
foreach (object dataItem in dataChildren)
{
System.Collections.Generic.List <CObject> matchedChildren
= new System.Collections.Generic.List <CObject>();
System.Collections.Generic.List <ArchetypeSlot> slots
= new System.Collections.Generic.List <ArchetypeSlot>();
IRmType rmType = dataItem as IRmType;
Check.Assert(rmType != null, string.Format(AmValidationStrings.XMustImplementY, dataItem.GetType().ToString(), "IRmType"));
ILocatable locatable = dataItem as ILocatable;
// get all child constraint objects with this data item's node_id
foreach (CObject eachChild in Children)
{
if (locatable == null || locatable.ArchetypeNodeId == eachChild.ArchetypeNodeId)
{
if (eachChild.IsSameRmType(rmType))
{
matchedChildren.Add(eachChild);
}
}
}
bool matchedWithSlot = false;
if (matchedChildren.Count == 0)
{
bool validationResult = true;
matchedWithSlot = MatchedWithSlot(locatable, out validationResult);
if (matchedWithSlot)
{
result &= validationResult;
}
else
{
// child constraint object not found for this data item
result = false;
string errorRmTypeName = rmType.GetRmTypeName();
ILocatable locatableDataItem = dataItem as ILocatable;
if (locatableDataItem != null)
{
ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.ItemXWithIdYNotAllowedByAttributeZ, errorRmTypeName, locatableDataItem.ArchetypeNodeId, RmAttributeName));
}
else
{
ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.ItemXNotAllowedByAttributeY, errorRmTypeName, RmAttributeName));
}
}
}
CObject unnamedMatchedObject = null;
bool validResult = false;
// attempt to match data item against child constraint objects with a name attribute constraint
foreach (CObject matchedObject in matchedChildren)
{
CComplexObject complexObject = matchedObject as CComplexObject;
if (complexObject == null)
{
throw new ApplicationException(AmValidationStrings.MultiAttributeChildNotComplexObj);
}
CAttribute nameAttribute = NameAttributeConstraint(complexObject);
if (nameAttribute != null)
{
bool nameAttributeFound = false;
AcceptValidationError previousErrorDelegate = ValidationContext.AcceptError;
try
{
ValidationContext.AcceptError = null;
nameAttributeFound = nameAttribute.ValidValue(locatable.Name);
}
finally
{
ValidationContext.AcceptError = previousErrorDelegate;
}
if (nameAttributeFound)
{
validResult = matchedObject.ValidValue(dataItem);
if (validResult)
{
break;
}
else
{
result = false;
}
}
}
else
{
// keep child constraint object with no name attribute constraint for later
if (unnamedMatchedObject != null)
{
throw new ApplicationException(AmValidationStrings.ExpectingOnlyOneUnnamedChild);
}
unnamedMatchedObject = matchedObject;
}
}
// no matching named object constraint, so attempt to validate against unnamed object constraint
if (!validResult && !matchedWithSlot)
{
if (unnamedMatchedObject == null)
{
result = false;
ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.NotAllowedByAttributeXConstraint, RmAttributeName));
}
else if (!unnamedMatchedObject.ValidValue(dataItem))
{
result = false;
}
}
}
return(result);
}
private AssertionContext ProcessPathPartWithWildcardForArId(AssertionContext contextObj, PathStep pathStep)
{
DesignByContract.Check.Require(pathStep.Attribute == "//*", "anyAttribute value must be //*.");
Locatable locatable = contextObj.Data as Locatable;
if (locatable != null)
{
ArchetypedPathProcessor archetypePathProcessor = new ArchetypedPathProcessor(locatable);
string archetypePathWithWildcardKey = null;
if (!string.IsNullOrEmpty(pathStep.ArchetypeNodeId))
{
archetypePathWithWildcardKey = pathStep.Attribute + "[" + pathStep.ArchetypeNodeId + "]";
}
else if (!string.IsNullOrEmpty(pathStep.NodePattern))
{
archetypePathWithWildcardKey = pathStep.Attribute + "[{/" + pathStep.NodePattern + "/}]";
}
else
{
throw new NotSupportedException(pathStep.Value + " path not supported");
}
object obj = null;
if (!archetypePathProcessor.PathExists(archetypePathWithWildcardKey))
{
return(null);
}
if (archetypePathProcessor.PathUnique(archetypePathWithWildcardKey))
{
obj = archetypePathProcessor.ItemAtPath(archetypePathWithWildcardKey);
}
else
{
obj = archetypePathProcessor.ItemsAtPath(archetypePathWithWildcardKey);
}
if (obj == null)
{
throw new ApplicationException("obj must not be null.");
}
return(new AssertionContext(obj, contextObj));
}
AssumedTypes.IList ilist = contextObj.Data as AssumedTypes.IList;
if (ilist == null)
{
throw new ApplicationException("only support either locatable or ilist");
}
AssumedTypes.List <object> results = new OpenEhr.AssumedTypes.List <object>();
foreach (Locatable locatableItem in ilist)
{
AssertionContext assertionContext = new AssertionContext(locatableItem, contextObj);
AssertionContext result = ProcessPathPartWithWildcardForArId(assertionContext, pathStep);
if (result != null && result.Data != null)
{
results.Add(result.Data);
}
}
if (results.Count > 0)
{
return(new AssertionContext(results, contextObj));
}
return(null);
}
internal AssertionContext Evaluate(AssertionContext contextObj)
{
if (contextObj == null)
{
return(null);
}
AssumedTypes.IList assumedIList = contextObj.Data as AssumedTypes.IList;
if (assumedIList != null)
{
AssumedTypes.List <object> results = new OpenEhr.AssumedTypes.List <object>();
foreach (object obj in assumedIList)
{
AssertionContext assertObj = new AssertionContext(obj, contextObj);
AssertionContext evaluateResult = Evaluate(assertObj);
if (evaluateResult != null)
{
AssumedTypes.List <object> aList = evaluateResult.Data as AssumedTypes.List <object>;
if (aList == null)
{
results.Add(evaluateResult.Data);
}
else
{
foreach (object o in aList)
{
results.Add(o);
}
}
}
}
if (results.Count == 0)
{
return(null);
}
return(new AssertionContext(results, contextObj));
}
System.Collections.IList list = contextObj.Data as System.Collections.IList;
if (list == null)
{
return(EvaluateSingleAttri(contextObj));
}
else
{
AssumedTypes.List <object> results = new AssumedTypes.List <object>();
foreach (object obj in list)
{
AssertionContext assertObj = new AssertionContext(obj, contextObj);
AssertionContext evaluateResult = Evaluate(assertObj);
if (evaluateResult != null)
{
results.Add(evaluateResult.Data);
}
}
if (results.Count == 0)
{
return(null);
}
return(new AssertionContext(results, contextObj));
}
}