Exemple #1
0
            public override bool IsExactly(IDeepComparable other)
            {
                var otherT = other as PositionComponent;

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

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(LongitudeElement, otherT.LongitudeElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(LatitudeElement, otherT.LatitudeElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(AltitudeElement, otherT.AltitudeElement))
                {
                    return(false);
                }

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

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

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(StatusElement, otherT.StatusElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Description, otherT.Description))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(DateTimeElement, otherT.DateTimeElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Actor, otherT.Actor))
                {
                    return(false);
                }

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

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

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

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

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

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Identifier, otherT.Identifier))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Code, otherT.Code))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Subject, otherT.Subject))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Author, otherT.Author))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(CreatedElement, otherT.CreatedElement))
            {
                return(false);
            }

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

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

                if (!base.IsExactly(otherT))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Code, otherT.Code))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Specimen, otherT.Specimen))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(BodySite, otherT.BodySite))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(StatusElement, otherT.StatusElement))
                {
                    return(false);
                }
                if (!DeepComparable.IsExactly(Event, otherT.Event))
                {
                    return(false);
                }

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

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

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

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

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

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(BodySite, otherT.BodySite))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(StatusElement, otherT.StatusElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Device, otherT.Device))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Encounter, otherT.Encounter))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Identifier, otherT.Identifier))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Indication, otherT.Indication))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(NotesElement, otherT.NotesElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(PrnReason, otherT.PrnReason))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(OrderedOnElement, otherT.OrderedOnElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(RecordedOnElement, otherT.RecordedOnElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Subject, otherT.Subject))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Timing, otherT.Timing))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(PriorityElement, otherT.PriorityElement))
            {
                return(false);
            }

            return(true);
        }
Exemple #8
0
        public override bool IsExactly(IDeepComparable other)
        {
            var otherT = other as Location;

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

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Identifier, otherT.Identifier))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(StatusElement, otherT.StatusElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(NameElement, otherT.NameElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(DescriptionElement, otherT.DescriptionElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ModeElement, otherT.ModeElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Type, otherT.Type))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Telecom, otherT.Telecom))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Address, otherT.Address))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(PhysicalType, otherT.PhysicalType))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Position, otherT.Position))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ManagingOrganization, otherT.ManagingOrganization))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(PartOf, otherT.PartOf))
            {
                return(false);
            }

            return(true);
        }
Exemple #9
0
        public override bool IsExactly(IDeepComparable other)
        {
            var otherT = other as Device;

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

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Identifier, otherT.Identifier))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Type, otherT.Type))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Note, otherT.Note))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(StatusElement, otherT.StatusElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ManufacturerElement, otherT.ManufacturerElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ModelElement, otherT.ModelElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(VersionElement, otherT.VersionElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ManufactureDateElement, otherT.ManufactureDateElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ExpiryElement, otherT.ExpiryElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(UdiElement, otherT.UdiElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(LotNumberElement, otherT.LotNumberElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Owner, otherT.Owner))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Location, otherT.Location))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Patient, otherT.Patient))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Contact, otherT.Contact))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(UrlElement, otherT.UrlElement))
            {
                return(false);
            }

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

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

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Subject, otherT.Subject))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Orderer, otherT.Orderer))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Identifier, otherT.Identifier))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Encounter, otherT.Encounter))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Reason, otherT.Reason))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(SupportingInformation, otherT.SupportingInformation))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Specimen, otherT.Specimen))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(StatusElement, otherT.StatusElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(PriorityElement, otherT.PriorityElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Event, otherT.Event))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Item, otherT.Item))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Note, otherT.Note))
            {
                return(false);
            }

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

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

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ActionElement, otherT.ActionElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Identifier, otherT.Identifier))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Ruleset, otherT.Ruleset))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(OriginalRuleset, otherT.OriginalRuleset))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(CreatedElement, otherT.CreatedElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Target, otherT.Target))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Provider, otherT.Provider))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Organization, otherT.Organization))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Request, otherT.Request))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Response, otherT.Response))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(NullifyElement, otherT.NullifyElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ReferenceElement, otherT.ReferenceElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Item, otherT.Item))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(IncludeElement, otherT.IncludeElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ExcludeElement, otherT.ExcludeElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Period, otherT.Period))
            {
                return(false);
            }

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

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

            if (!base.IsExactly(otherT))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(UrlElement, otherT.UrlElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(NameElement, otherT.NameElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(StatusElement, otherT.StatusElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(ExperimentalElement, otherT.ExperimentalElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(PublisherElement, otherT.PublisherElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(Contact, otherT.Contact))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(DateElement, otherT.DateElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(RequirementsElement, otherT.RequirementsElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(CodeElement, otherT.CodeElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(BaseElement, otherT.BaseElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(TypeElement, otherT.TypeElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(DescriptionElement, otherT.DescriptionElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(XpathElement, otherT.XpathElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(XpathUsageElement, otherT.XpathUsageElement))
            {
                return(false);
            }
            if (!DeepComparable.IsExactly(TargetElement, otherT.TargetElement))
            {
                return(false);
            }

            return(true);
        }