示例#1
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as PredictionComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Outcome, otherT.Outcome))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Probability, otherT.Probability))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(RelativeRiskElement, otherT.RelativeRiskElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(When, otherT.When))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(RationaleElement, otherT.RationaleElement))
                {
                    return(false);
                }

                return(true);
            }
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as InvestigationsComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Code, otherT.Code))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Item, otherT.Item))
                {
                    return(false);
                }

                return(true);
            }
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as RuledOutComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Item, otherT.Item))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(ReasonElement, otherT.ReasonElement))
                {
                    return(false);
                }

                return(true);
            }
示例#4
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as BatchIdentifierComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(OuterPackaging, otherT.OuterPackaging))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(ImmediatePackaging, otherT.ImmediatePackaging))
                {
                    return(false);
                }

                return(true);
            }
            public override bool Matches(IDeepComparable other)
            {
                var otherT = other as ClinicalImpressionFindingComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.Matches(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(Item, otherT.Item))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(CauseElement, otherT.CauseElement))
                {
                    return(false);
                }

                return(true);
            }
示例#6
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as NotesComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(TypeElement, otherT.TypeElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(TextElement, otherT.TextElement))
                {
                    return(false);
                }

                return(true);
            }
示例#7
0
        public override bool IsExactly(IDeepComparable other)
        {
            var otherT = other as Coding;

            if (otherT == null)
            {
                return(false);
            }

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(SystemElement, otherT.SystemElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(VersionElement, otherT.VersionElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(CodeElement, otherT.CodeElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(DisplayElement, otherT.DisplayElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(UserSelectedElement, otherT.UserSelectedElement))
            {
                return(false);
            }

            return(true);
        }
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as MedicationProductIngredientComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Item, otherT.Item))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Amount, otherT.Amount))
                {
                    return(false);
                }

                return(true);
            }
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as MedicationProductBatchComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(LotNumberElement, otherT.LotNumberElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(ExpirationDateElement, otherT.ExpirationDateElement))
                {
                    return(false);
                }

                return(true);
            }
            public override bool Matches(IDeepComparable other)
            {
                var otherT = other as MedicationPackageContentComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.Matches(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(Item, otherT.Item))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(Amount, otherT.Amount))
                {
                    return(false);
                }

                return(true);
            }
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as MedicationPackageComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Container, otherT.Container))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Content, otherT.Content))
                {
                    return(false);
                }

                return(true);
            }
示例#12
0
        public override bool IsExactly(IDeepComparable other)
        {
            var otherT = other as Meta;

            if (otherT == null)
            {
                return(false);
            }

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(VersionIdElement, otherT.VersionIdElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(LastUpdatedElement, otherT.LastUpdatedElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ProfileElement, otherT.ProfileElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Security, otherT.Security))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Tag, otherT.Tag))
            {
                return(false);
            }

            return(true);
        }
示例#13
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as ExplanationComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Reason, otherT.Reason))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(ReasonNotGiven, otherT.ReasonNotGiven))
                {
                    return(false);
                }

                return(true);
            }
示例#14
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as LinkComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Target, otherT.Target))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(AssuranceElement, otherT.AssuranceElement))
                {
                    return(false);
                }

                return(true);
            }
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as AnswerComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Value, otherT.Value))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Group, otherT.Group))
                {
                    return(false);
                }

                return(true);
            }
示例#16
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as CommunicationComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Language, otherT.Language))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(PreferredElement, otherT.PreferredElement))
                {
                    return(false);
                }

                return(true);
            }
示例#17
0
        public override bool IsExactly(IDeepComparable other)
        {
            var otherT = other as ContactPoint;

            if (otherT == null)
            {
                return(false);
            }

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(SystemElement, otherT.SystemElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ValueElement, otherT.ValueElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(UseElement, otherT.UseElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(RankElement, otherT.RankElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Period, otherT.Period))
            {
                return(false);
            }

            return(true);
        }
示例#18
0
            public override bool Matches(IDeepComparable other)
            {
                var otherT = other as LinkComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.Matches(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(Other, otherT.Other))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(TypeElement, otherT.TypeElement))
                {
                    return(false);
                }

                return(true);
            }
示例#19
0
        public override bool IsExactly(IDeepComparable other)
        {
            var otherT = other as Range;

            if (otherT == null)
            {
                return(false);
            }

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Low, otherT.Low))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(High, otherT.High))
            {
                return(false);
            }

            return(true);
        }
示例#20
0
            public override bool Matches(IDeepComparable other)
            {
                var otherT = other as NotesComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.Matches(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(Type, otherT.Type))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(TextElement, otherT.TextElement))
                {
                    return(false);
                }

                return(true);
            }
示例#21
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as EvidenceComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Code, otherT.Code))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Detail, otherT.Detail))
                {
                    return(false);
                }

                return(true);
            }
示例#22
0
        public override bool IsExactly(IDeepComparable other)
        {
            var otherT = other as Quantity;

            if (otherT == null)
            {
                return(false);
            }

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ValueElement, otherT.ValueElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ComparatorElement, otherT.ComparatorElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(UnitElement, otherT.UnitElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(SystemElement, otherT.SystemElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(CodeElement, otherT.CodeElement))
            {
                return(false);
            }

            return(true);
        }
            public override bool Matches(IDeepComparable other)
            {
                var otherT = other as ClinicalImpressionInvestigationsComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.Matches(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(Code, otherT.Code))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(Item, otherT.Item))
                {
                    return(false);
                }

                return(true);
            }
示例#24
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as RequesterComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Agent, otherT.Agent))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(OnBehalfOf, otherT.OnBehalfOf))
                {
                    return(false);
                }

                return(true);
            }
            public override bool Matches(IDeepComparable other)
            {
                var otherT = other as ClinicalImpressionRuledOutComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.Matches(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(Item, otherT.Item))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(ReasonElement, otherT.ReasonElement))
                {
                    return(false);
                }

                return(true);
            }
示例#26
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as ExemptionComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Type, otherT.Type))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Period, otherT.Period))
                {
                    return(false);
                }

                return(true);
            }
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as FindingComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Item, otherT.Item))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(CauseElement, otherT.CauseElement))
                {
                    return(false);
                }

                return(true);
            }
示例#28
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as StageComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Summary, otherT.Summary))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Assessment, otherT.Assessment))
                {
                    return(false);
                }

                return(true);
            }
示例#29
0
            public override bool Matches(IDeepComparable other)
            {
                var otherT = other as ContactComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.Matches(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(NameElement, otherT.NameElement))
                {
                    return(false);
                }
                if (!DeepComparable.Matches(Telecom, otherT.Telecom))
                {
                    return(false);
                }

                return(true);
            }
示例#30
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as IssueComponent;

                if (otherT == null)
                {
                    return(false);
                }

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(SeverityElement, otherT.SeverityElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(CodeElement, otherT.CodeElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Details, otherT.Details))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(DiagnosticsElement, otherT.DiagnosticsElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(LocationElement, otherT.LocationElement))
                {
                    return(false);
                }

                return(true);
            }