예제 #1
0
        public override bool ValidValue(object aValue)
        {
            Check.Require(aValue != null, string.Format(CommonStrings.XMustNotBeNull, "aValue"));

            CComplexObject rootDefinition = AmFactory.GetRootDefinition(this);

            CObject cObjAtTargetPath = Archetype.GetCObjectAtTargetPath(rootDefinition, this.TargetPath);

            return(cObjAtTargetPath.ValidValue(aValue));
        }
예제 #2
0
        protected override System.Collections.Generic.List <string> GetPhysicalPaths()
        {
            CComplexObject rootDefinition = AmFactory.GetRootDefinition(this);

            CObject cObjAtTargetPath = Archetype.GetCObjectAtTargetPath(rootDefinition, this.TargetPath);

            if (cObjAtTargetPath == null)
            {
                throw new ApplicationException(string.Format(
                                                   AmValidationStrings.NoNodeMatchAtPath, this.TargetPath));
            }

            return(cObjAtTargetPath.PhysicalPaths);
        }
예제 #3
0
        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);
        }
예제 #4
0
            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);
            }
예제 #5
0
        public static string LocalTermDefText(string codeString, CObject cObject)
        {
            Check.Require(!string.IsNullOrEmpty(codeString), "codeString must not be null or empty.");
            Check.Require(cObject != null, "cObject must not be null");

            CArchetypeRoot cArchetypeRoot = GetCArchetypeRoot(cObject);

            Check.Assert(cArchetypeRoot.TermDefinitions.HasKey(codeString));

            string termDefText = cArchetypeRoot.TermDefinitions.Item(codeString).Items.Item("text");

            Check.Ensure(!string.IsNullOrEmpty(termDefText));

            return termDefText;
        }
예제 #6
0
        internal static bool ValidateCObject(CObject cObject, ITerminologyService terminologyService)
        {
            AmValidator amValidator = new AmValidator(terminologyService);

            try
            {
                amValidator.Validate(cObject);
            }
            catch (Exception ex)
            {
                if (ex.GetType() == typeof(RmInvariantException))
                    return false;
                else
                    throw ex;
            }

            return true;
        }
예제 #7
0
        internal static CArchetypeRoot GetCArchetypeRoot(CObject cObject)
        {
            Check.Require(cObject != null, "cObject must not be null");

            CObject parentObject = cObject;
            CArchetypeRoot cArchetypeRoot = null;
            while (parentObject != null && (cArchetypeRoot = parentObject as CArchetypeRoot) == null)
            {
                CAttribute cattribute = parentObject.Parent;
                Check.Assert(cattribute != null, "cattribute must not be null");
                parentObject = cattribute.parent;
            }

            if (cArchetypeRoot == null)
                throw new ApplicationException("Operational template must contain CArchetypeRoot");

            return cArchetypeRoot;
        }
예제 #8
0
        public static bool HasNameAttributeConstraint(CObject objectConstraint, DvText name, bool requireNameConstraint)
        {
            CAttribute nameConstraint = NameAttributeConstraint(objectConstraint);

            if (nameConstraint == null)
            {
                if (requireNameConstraint)
                {
                    return(false);
                }

                return(true);
            }

            bool nameFound = nameConstraint.ValidValue(name);

            return(nameFound);
        }
예제 #9
0
        static private CAttribute NameAttributeConstraint(CObject objectConstraint)
        {
            Check.Require(objectConstraint != null, string.Format(CommonStrings.XMustNotBeNull, "objectConstraint"));

            CComplexObject cComplexObject = objectConstraint as CComplexObject;

            if (cComplexObject != null && cComplexObject.Attributes != null)
            {
                foreach (CAttribute attribute in cComplexObject.Attributes)
                {
                    if (attribute.RmAttributeName == "name")
                    {
                        return(attribute);
                    }
                }
            }

            return(null);
        }
예제 #10
0
        public override bool ValidValue(object dataValue)
        {
            Check.Require(dataValue != null, string.Format(CommonStrings.XMustNotBeNull, "dataValue"));
            IRmType rmType = dataValue as IRmType;

            Check.Require(rmType != null, string.Format(AmValidationStrings.ValueMustImplementIRmType, dataValue.GetType().ToString()));

            bool result = true;

            rmType.Constraint = this;

            if (!IsSameRmType(rmType))
            {
                result = false;
                ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.IncorrectRmType, RmTypeName, rmType.GetRmTypeName()));
            }

            if (!result || !AnyAllowed())
            {
                OpenEhr.RM.Common.Archetyped.Impl.Locatable locatable = dataValue as OpenEhr.RM.Common.Archetyped.Impl.Locatable;

                if (locatable != null)
                {
                    ValidationUtility.PopulateLocatableAttributes(this, locatable);

                    if (Parent != null && ArchetypeNodeId != locatable.ArchetypeNodeId)
                    {
                        result = false;
                        ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.IncorrectNodeId, ArchetypeNodeId, locatable.ArchetypeNodeId));
                    }
                }

                System.ComponentModel.PropertyDescriptorCollection propertyDescriptorCollection = System.ComponentModel.TypeDescriptor.GetProperties(dataValue);

                if (Attributes != null)
                {
                    foreach (CAttribute cAttribute in Attributes)
                    {
                        object attributeObject = null;
                        string attributeName   = RmFactory.GetOpenEhrV1RmName(cAttribute.RmAttributeName);
                        System.ComponentModel.PropertyDescriptor property = propertyDescriptorCollection.Find(attributeName, true);

                        // if the attributeName is not a class property, it must be a class function.
                        if (property == null)
                        {
                            System.Reflection.MethodInfo method = dataValue.GetType().GetMethod(attributeName);

                            if (method == null)
                            {
                                result = false;
                                ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.UnexpectedAttributeX, attributeName));
                                continue;
                            }
                            else
                            {
                                attributeObject = method.Invoke(dataValue, null);
                            }
                        }
                        else
                        {
                            attributeObject = property.GetValue(dataValue);
                        }

                        if (attributeObject == null)
                        {
                            if (cAttribute.Existence.Lower > 0)
                            {
                                result = false;
                                ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.TmExpectedConstraintMissing, cAttribute.RmAttributeName));
                            }
                        }
                        else if (cAttribute.Existence.Upper == 0)
                        {
                            result = false;
                            ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.TmForbiddenConstraint, cAttribute.RmAttributeName));
                        }
                        else if (!cAttribute.ValidValue(attributeObject))
                        {
                            result = false;
                        }
                        else
                        {
                            DvCodedText codedText = dataValue as DvCodedText;

                            if (codedText != null && cAttribute.RmAttributeName == "defining_code")
                            {
                                // validate the code string before validating the coded value
                                if (codedText.DefiningCode.TerminologyId.Value == "local")
                                {
                                    CObject        parentObject   = cAttribute.parent;
                                    CArchetypeRoot cArchetypeRoot = ValidationUtility.GetCArchetypeRoot(parentObject);

                                    if (!cArchetypeRoot.TermDefinitions.HasKey(codedText.DefiningCode.CodeString))
                                    {
                                        result = false;
                                        string code = codedText.DefiningCode == null ? "" : codedText.DefiningCode.CodeString;
                                        ValidationContext.AcceptValidationError(this, string.Format("code {0} is not existing archetype term", code));
                                    }
                                }
                                if (result && !ValidationUtility.ValidValueTermDef(codedText, cAttribute, ValidationContext.TerminologyService))
                                {
                                    result = false;
                                    string code = codedText.DefiningCode == null ? "" : codedText.DefiningCode.CodeString;
                                    ValidationContext.AcceptValidationError(this, string.Format(AmValidationStrings.TextValueXInvalidForCodeY, codedText.Value, code));
                                }
                            }
                        }
                    }
                }
            }

            return(result);
        }
예제 #11
0
        public CObject ConstraintAtPath(string path)
        {
            if (string.IsNullOrEmpty(path))
            {
                return(this);
            }

            if (constraintAtPath.Contains(path))
            {
                return(constraintAtPath[path] as CObject);
            }

            CObject        constraintFound = null;
            ConstraintPath constraintPath  = new ConstraintPath(path);

            if (path.StartsWith("/") && this.Parent != null)
            {
                ArchetypeConstraint rootConstraint = this.ConstraintParent;
                while (rootConstraint.ConstraintParent != null)
                {
                    rootConstraint = rootConstraint.ConstraintParent;
                }

                CComplexObject cComplexObject = rootConstraint as CComplexObject;
                if (cComplexObject == null)
                {
                    throw new ArgumentException(AmValidationStrings.RootConstraintInvalid);
                }

                constraintFound = cComplexObject.ConstraintAtPath(path);
            }
            else
            {
                foreach (CAttribute attribute in this.attributes)
                {
                    if (attribute.RmAttributeName == constraintPath.FirstStepAttributeName)
                    {
                        System.Collections.Generic.IList <CObject> matchedChildren
                            = new System.Collections.Generic.List <CObject>();
                        foreach (CObject cObject in attribute.Children)
                        {
                            if (cObject.NodeId == constraintPath.FirstStepNodeId)
                            {
                                matchedChildren.Add(cObject);
                            }
                            else if (cObject is CArchetypeRoot && cObject.ArchetypeNodeId == constraintPath.FirstStepNodeId)
                            {
                                matchedChildren.Add(cObject);
                            }
                        }
                        if (matchedChildren.Count <= 0)
                        {
                            throw new ArgumentException(string.Format(AmValidationStrings.
                                                                      MissingChildrenWithNodeIdX, constraintPath.FirstStepNodeId));
                        }
                        else if (matchedChildren.Count == 1)
                        {
                            constraintFound = matchedChildren[0];
                        }

                        else if (!constraintPath.HasNameConstraint())
                        {
                            throw new ArgumentException(string.Format(AmValidationStrings.PathYNotUniqueAtX,
                                                                      constraintPath.ToString(), constraintPath.FirstStepNodeId));
                        }
                        else
                        {
                            DvText name = (!string.IsNullOrEmpty(constraintPath.FirstStepNameValue) ?
                                           new DvText(constraintPath.FirstStepNameValue) :
                                           new DvCodedText(constraintPath.FirstStepName));

                            foreach (CObject cObject in matchedChildren)
                            {
                                if (CMultipleAttribute.HasNameAttributeConstraint(cObject, name))
                                {
                                    constraintFound = cObject;
                                    break;
                                }
                            }
                        }
                        break;
                    }
                }
            }

            if (constraintFound == null)
            {
                throw new ArgumentException(string.Format(AmValidationStrings.NoConstraintForPathX, path));
            }

            CComplexObject complexObject = constraintFound as CComplexObject;

            if (complexObject != null)
            {
                constraintFound = complexObject.ConstraintAtPath(constraintPath.NextSteps);
            }

            this.constraintAtPath.Add(path, constraintFound);

            Check.Ensure(constraintFound != null);

            return(constraintFound);
        }
예제 #12
0
 public static bool HasNameAttributeConstraint(CObject objectConstraint, DvText name)
 {
     return(HasNameAttributeConstraint(objectConstraint, name, false));
 }
예제 #13
0
        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);
        }
예제 #14
0
        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);
        }
예제 #15
0
 public void ReadCObject(XmlReader reader, CObject cObject)
 {
     this.reader = reader;
     ReadXml(cObject);
 }
예제 #16
0
        private void ReadXmlBase(CObject cObject)
        {
            DesignByContract.Check.Require(cObject != null, "cObject must not be null.");

            if (reader.LocalName != "rm_type_name")
            {
                throw new ValidationException("expected local name is rm_type_name, but it is " + reader.LocalName);
            }
            cObject.RmTypeName = reader.ReadElementContentAsString("rm_type_name", OpenEhrNamespace);
            reader.MoveToContent();

            if (reader.LocalName != "occurrences")
                throw new InvalidXmlException("occurrences", reader.LocalName);
            cObject.Occurrences = new OpenEhr.AssumedTypes.Interval<int>();
            this.ReadXml(cObject.Occurrences);

            if (reader.LocalName != "node_id")
                throw new InvalidXmlException("node_id", reader.LocalName);
            cObject.NodeId = reader.ReadElementContentAsString("node_id", OpenEhrNamespace);
            reader.MoveToContent();
        }
예제 #17
0
        protected void ValidateBase(CObject cObject)
        {
            this.Validate((ArchetypeConstraint)cObject);

            Invariant(!string.IsNullOrEmpty(cObject.RmTypeName), string.Format(
                CommonStrings.XMustNotBeNullOrEmpty, "CObject.RmTypeName"));
            Invariant(cObject.Occurrences!= null,  string.Format(
                CommonStrings.XMustNotBeNull, "CObject.Occurrences"));
            this.Validate(cObject.Occurrences);

            // TODO: nodeId invariants checking

            if (cObject.Parent != null)
            {
                Invariant(cObject.Parent.GetType() != typeof(CSingleAttribute) || cObject.Occurrences.Upper <= 1,
                   AmValidationStrings.SingleParentOccurrencesBad);
            }
        }
예제 #18
0
        protected void Validate(CObject cObject)
        {
            if (cObject == null) throw new ArgumentNullException(string.Format(
                CommonStrings.XMustNotBeNull, "cObject"));

            const string methodName = "Validate";

            try
            {
                System.Reflection.MethodInfo method = this.GetType().GetMethod(methodName,
                    System.Reflection.BindingFlags.ExactBinding | System.Reflection.BindingFlags.NonPublic
                    | System.Reflection.BindingFlags.Instance, Type.DefaultBinder,
                               new Type[] { cObject.GetType() },
                               new System.Reflection.ParameterModifier[0]);

                if (method != null)
                {
                    // Avoid StackOverflow exceptions by executing only if the method and visitable
                    // are different from the last parameters used.
                    if (method != lastCObjectMethod || cObject != lastCObject)
                    {
                        lastCObjectMethod = method;
                        lastCObject = cObject;

                        method.Invoke(this, new Object[] { cObject });

                    }
                    else
                    {
                        string message = string.Format(CommonStrings.LoopingMethodTerminated,
                            methodName, cObject.GetType().ToString());
                        System.Diagnostics.Debug.WriteLine(message);
                        throw new ApplicationException(message);
                    }
                }
                else
                {
                    string message = string.Format(CommonStrings.MethodXNotImplementedForParamTypeY,
                        methodName, cObject.GetType().ToString());
                    System.Diagnostics.Debug.WriteLine(message);
                    throw new ApplicationException(message);
                }
            }
            catch (Exception ex)
            {
                if (ex.InnerException != null)
                    if (ex.InnerException is ApplicationException && ex.InnerException.InnerException != null
                            && ex.InnerException.Message == ex.InnerException.InnerException.Message)
                        throw new ApplicationException(ex.InnerException.Message, ex.InnerException.InnerException);
                    else
                        throw new ApplicationException(ex.InnerException.Message, ex.InnerException);
                else
                    throw new ApplicationException(ex.Message, ex);
            }
        }
예제 #19
0
        public void WriteCObject(XmlWriter writer, CObject cObject)
        {
            this.writer = writer;

            //Changed by LMT 29/Apr/2009
            if(cObject is CComplexObject)
                WriteXmlBase(cObject);
            else
                this.WriteXml(cObject);
        }
예제 #20
0
        private void WriteXmlBase(CObject cObject)
        {
            Check.Require(cObject != null, string.Format(CommonStrings.XMustNotBeNull, "cObject"));
            Check.Require(!string.IsNullOrEmpty(cObject.RmTypeName), string.Format(CommonStrings.XMustNotBeNullOrEmpty, "cObject.RmTypeName"));
            Check.Require(cObject.Occurrences != null, string.Format(CommonStrings.XMustNotBeNull, "cObject.Occurrences"));

            string openEhrPrefix = UseOpenEhrPrefix(writer);
            writer.WriteElementString(openEhrPrefix, "rm_type_name", OpenEhrNamespace, cObject.RmTypeName);
            writer.WriteStartElement(openEhrPrefix, "occurrences", OpenEhrNamespace);
            this.WriteXml(cObject.Occurrences);
            writer.WriteEndElement();
            writer.WriteElementString(openEhrPrefix, "node_id", OpenEhrNamespace, cObject.NodeId);
        }
예제 #21
0
        private void ReadXml(CObject cObject)
        {
            if (cObject == null) throw new ArgumentNullException(string.Format(CommonStrings.XIsNull, "cObject"));

            const string methodName = "ReadXml";

            try
            {
                System.Reflection.MethodInfo method = this.GetType().GetMethod(methodName,
                    System.Reflection.BindingFlags.ExactBinding | System.Reflection.BindingFlags.NonPublic
                    | System.Reflection.BindingFlags.Instance, Type.DefaultBinder,
                               new Type[] { cObject.GetType() },
                               new System.Reflection.ParameterModifier[0]);

                if (method != null)
                {
                    if (method != lastMethodReadCObject || cObject!= lastCObjectRead)
                    {
                        lastMethodReadCObject = method;
                        lastCObjectRead = cObject;

                        method.Invoke(this, new Object[] { cObject });

                    }
                    else
                    {
                        string message = string.Format(CommonStrings.LoopingMethodTerminated, methodName, cObject.GetType().ToString());
                        System.Diagnostics.Debug.WriteLine(message);
                        throw new ApplicationException(message);
                    }
                }
                else
                {
                    string message = string.Format(CommonStrings.MethodXNotImplementedForParamTypeY, methodName, cObject.GetType().ToString());
                    System.Diagnostics.Debug.WriteLine(message);
                    throw new ApplicationException(message);
                }
            }
            catch (System.Reflection.TargetInvocationException ex)
            {
                if (ex.InnerException != null)
                    throw new ApplicationException(ex.InnerException.Message, ex.InnerException);
                else
                    throw new ApplicationException(ex.Message, ex);
            }
        }