예제 #1
0
        /// <summary>
        /// Compare the two messages.
        /// </summary>
        /// <param name="resultsReporter">Results reporter.</param>
        /// <param name="thatBaseComparator">Reference comparator.</param>
        /// <returns>bool - true = messages compared, false messages not compared</returns>
        public override bool Compare(ResultsReporter resultsReporter, BaseComparator thatBaseComparator)
        {
            bool compared = false;

            if (thatBaseComparator is DicomComparator)
            {
                DicomComparator thatDicomComparator = (DicomComparator)thatBaseComparator;

                // Check if both templates have been initialized correctly
                if ((this._template == null) ||
                    (thatDicomComparator._template == null))
                {
                    return(false);
                }

                // Check for comparator equality
                if (this == thatDicomComparator)
                {
                    return(true);
                }

                MessageComparisonResults messageComparisonResults
                    = new MessageComparisonResults(this._name,
                                                   thatDicomComparator._name,
                                                   this._template.Command,
                                                   thatDicomComparator._template.Command,
                                                   this._template.SopClassUid,
                                                   thatDicomComparator._template.SopClassUid);

                // Iterate over this comparator
                foreach (DicomComparisonTag thisComparisonTag in this._template.ComparisonTags)
                {
                    // try to get the equivalent tag in thatDicomComparator
                    DicomComparisonTag thatComparisonTag = thatDicomComparator._template.ComparisonTags.Find(thisComparisonTag.Tag);
                    if (thatComparisonTag != null)
                    {
                        AttributeComparisonResults attributeComparisonResults
                            = new AttributeComparisonResults(thisComparisonTag.Tag,
                                                             thisComparisonTag.DataFormat.ToDicomFormat(),
                                                             thatComparisonTag.DataFormat.ToDicomFormat());

                        if (thisComparisonTag.DataFormat.Equals(thatComparisonTag.DataFormat) == false)
                        {
                            DvtkData.Validation.ValidationMessage validationMessage = new DvtkData.Validation.ValidationMessage();
                            validationMessage.Type    = DvtkData.Validation.MessageType.Error;
                            validationMessage.Message = "Attribute values do not match.";

                            attributeComparisonResults.Messages.Add(validationMessage);
                        }
                        messageComparisonResults.Add(attributeComparisonResults);
                    }
                }

                resultsReporter.WriteMessageComparisonResults(messageComparisonResults);

                compared = true;
            }

            return(compared);
        }
예제 #2
0
        /// <summary>
        /// Compare the two messages.
        /// </summary>
        /// <param name="resultsReporter">Results reporter.</param>
        /// <param name="thatBaseComparator">Reference comparator.</param>
        /// <returns>bool - true = messages compared, false messages not compared</returns>
        public override bool Compare(ResultsReporter resultsReporter, BaseComparator thatBaseComparator)
        {
            bool compared = false;

            if (thatBaseComparator is DicomComparator)
            {
                DicomComparator thatDicomComparator = (DicomComparator)thatBaseComparator;

                // Check if both templates have been initialized correctly
                if ((this._template == null) ||
                    (thatDicomComparator._template == null))
                {
                    return false;
                }

                // Check for comparator equality
                if (this == thatDicomComparator)
                {
                    return true;
                }

                MessageComparisonResults messageComparisonResults
                    = new MessageComparisonResults(this._name,
                                                thatDicomComparator._name,
                                                this._template.Command,
                                                thatDicomComparator._template.Command,
                                                this._template.SopClassUid,
                                                thatDicomComparator._template.SopClassUid);

                // Iterate over this comparator
                foreach (DicomComparisonTag thisComparisonTag in this._template.ComparisonTags)
                {
                    // try to get the equivalent tag in thatDicomComparator
                    DicomComparisonTag thatComparisonTag = thatDicomComparator._template.ComparisonTags.Find(thisComparisonTag.Tag);
                    if (thatComparisonTag != null)
                    {
                        AttributeComparisonResults attributeComparisonResults
                            = new AttributeComparisonResults(thisComparisonTag.Tag,
                                                            thisComparisonTag.DataFormat.ToDicomFormat(),
                                                            thatComparisonTag.DataFormat.ToDicomFormat());

                        if (thisComparisonTag.DataFormat.Equals(thatComparisonTag.DataFormat) == false)
                        {
                            DvtkData.Validation.ValidationMessage validationMessage = new DvtkData.Validation.ValidationMessage();
                            validationMessage.Type = DvtkData.Validation.MessageType.Error;
                            validationMessage.Message = "Attribute values do not match.";

                            attributeComparisonResults.Messages.Add(validationMessage);
                        }
                        messageComparisonResults.Add(attributeComparisonResults);
                    }
                }

                resultsReporter.WriteMessageComparisonResults(messageComparisonResults);

                compared = true;
            }

            return compared;
        }
예제 #3
0
        /// <summary>
        /// Compare the two messages.
        /// </summary>
        /// <param name="tagValueFilterCollection">Tag Value Filter.</param>
        /// <param name="resultsReporter">Results reporter.</param>
        /// <param name="thatBaseComparator">Reference comparator.</param>
        /// <returns>bool - true = messages compared, false messages not compared</returns>
        public override bool Compare(TagValueCollection tagValueFilterCollection, ResultsReporter resultsReporter, BaseComparator thatBaseComparator)
        {
            bool compared = false;

            if (thatBaseComparator is Hl7Comparator)
            {
                Hl7Comparator thatHl7Comparator = (Hl7Comparator)thatBaseComparator;

                // Check if both templates have been initialized correctly
                if ((this.Template == null) ||
                    (thatHl7Comparator.Template == null))
                {
                    return(false);
                }

                // Check for comparator equality
                if (this == thatHl7Comparator)
                {
                    return(true);
                }

                // filter out comparators for the same message types
                if ((this.Template.MessageType == thatHl7Comparator.Template.MessageType) &&
                    (this.Template.MessageSubType == thatHl7Comparator.Template.MessageSubType))
                {
                    return(false);
                }

                // generate a local Tag Value collection from this
                // - this collection will include any tag value pair from the original collection and
                // the tag value pairs of any tags only (in the original collection) that match from this
                // comparator - that is the values are taken from this comparator.
                TagValueCollection lTagValueFilterCollection = GenerateTagValueCollection(tagValueFilterCollection);

                // check to see if the comparision filters match - without Univeral Matching
                // - now try to match this local filter collection against thatDicomComparator
                // - comparators that match will have the same tag value pairs (including the value) as
                // each other.
                if ((tagValueFilterCollection.Count == lTagValueFilterCollection.Count) &&
                    (thatHl7Comparator.UseComparator(lTagValueFilterCollection, false) == true))
                {
                    MessageComparisonResults messageComparisonResults
                        = new MessageComparisonResults(this.Name,
                                                       thatHl7Comparator.Name,
                                                       this.Template.MessageType,
                                                       thatHl7Comparator.Template.MessageType,
                                                       this.Template.MessageSubType,
                                                       thatHl7Comparator.Template.MessageSubType);

                    // Iterate over this comparator
                    foreach (Hl7ComparisonTag thisComparisonTag in this.Template.ComparisonTags)
                    {
                        // try to get the equivalent tag in thatHl7Comparator
                        Hl7ComparisonTag thatComparisonTag = thatHl7Comparator.Template.ComparisonTags.Find(thisComparisonTag.Tag);
                        if (thatComparisonTag != null)
                        {
                            AttributeComparisonResults attributeComparisonResults
                                = new AttributeComparisonResults(SegmentNames.Name(thisComparisonTag.Tag.Segment),
                                                                 thisComparisonTag.Tag.FieldIndex,
                                                                 thisComparisonTag.DataFormat.ToHl7Format(),
                                                                 thatComparisonTag.DataFormat.ToHl7Format());
                            attributeComparisonResults.Name = DicomHl7TagMapTemplate.Hl7NameFromHl7Tag(thisComparisonTag.Tag);
                            if (thisComparisonTag.DataFormat.Equals(thatComparisonTag.DataFormat) == false)
                            {
                                DvtkData.Validation.ValidationMessage validationMessage = new DvtkData.Validation.ValidationMessage();
                                validationMessage.Type    = DvtkData.Validation.MessageType.Error;
                                validationMessage.Message = "Attribute values do not match.";

                                attributeComparisonResults.Messages.Add(validationMessage);
                            }
                            messageComparisonResults.Add(attributeComparisonResults);
                        }
                    }

                    resultsReporter.WriteMessageComparisonResults(messageComparisonResults);

                    compared = true;
                }
            }
            else if (thatBaseComparator is DicomComparator)
            {
                DicomComparator thatDicomComparator = (DicomComparator)thatBaseComparator;

                // Check if both templates have been initialized correctly
                if ((this.Template == null) ||
                    (thatDicomComparator.Template == null))
                {
                    return(false);
                }

                // generate a local Tag Value collection from this
                // - this collection will include any tag value pair from the original collection and
                // the tag value pairs of any tags only (in the original collection) that match from this
                // comparator - that is the values are taken from this comparator.
                TagValueCollection lTagValueFilterCollection = GenerateTagValueCollection(tagValueFilterCollection);

                // check to see if the comparision filters match - without Univeral Matching
                // - now try to match this local filter collection against thatDicomComparator
                // - comparators that match will have the same tag value pairs (including the value) as
                // each other.
                if ((tagValueFilterCollection.Count == lTagValueFilterCollection.Count) &&
                    (thatDicomComparator.UseComparator(lTagValueFilterCollection, false) == true))
                {
                    MessageComparisonResults messageComparisonResults
                        = new MessageComparisonResults(this.Name,
                                                       thatDicomComparator.Name,
                                                       this.Template.MessageType,
                                                       thatDicomComparator.Template.Command,
                                                       this.Template.MessageSubType,
                                                       thatDicomComparator.Template.SopClassUid);

                    // Iterate over this comparator
                    foreach (Hl7ComparisonTag thisComparisonTag in this.Template.ComparisonTags)
                    {
                        // try to get the equivalent tag in thatDicomComparator
                        DicomComparisonTag thatComparisonTag = thatDicomComparator.Template.ComparisonTags.Find(DicomHl7TagMapTemplate.Hl7ToDicomTag(thisComparisonTag.Tag));
                        if (thatComparisonTag != null)
                        {
                            AttributeComparisonResults attributeComparisonResults
                                = new AttributeComparisonResults(thatComparisonTag.Tag,
                                                                 SegmentNames.Name(thisComparisonTag.Tag.Segment),
                                                                 thisComparisonTag.Tag.FieldIndex,
                                                                 thisComparisonTag.DataFormat.ToHl7Format(),
                                                                 thatComparisonTag.DataFormat.ToDicomFormat());

                            if (thisComparisonTag.DataFormat.Equals(thatComparisonTag.DataFormat) == false)
                            {
                                DvtkData.Validation.ValidationMessage validationMessage = new DvtkData.Validation.ValidationMessage();
                                validationMessage.Type    = DvtkData.Validation.MessageType.Error;
                                validationMessage.Message = "Attribute values do not match.";

                                attributeComparisonResults.Messages.Add(validationMessage);
                            }
                            messageComparisonResults.Add(attributeComparisonResults);
                        }
                    }

                    resultsReporter.WriteMessageComparisonResults(messageComparisonResults);

                    compared = true;
                }
            }

            return(compared);
        }
예제 #4
0
 /// <summary>
 /// Adds an object to the end of the <see cref="BaseComparatorCollection"/>.
 /// </summary>
 /// <param name="value">The <see cref="BaseComparator"/> to be added to the end of the <see cref="BaseComparatorCollection"/>.</param>
 /// <returns>The <see cref="BaseComparatorCollection"/> index at which the value has been added.</returns>
 public int Add(BaseComparator value)
 {
     return (List.Add(value));
 }
예제 #5
0
 /// <summary>
 /// Removes the first occurrence of a specific <see cref="BaseComparator"/> from the <see cref="BaseComparatorCollection"/>.
 /// </summary>
 /// <param name="value">The <see cref="BaseComparator"/> to remove from the <see cref="BaseComparatorCollection"/>.</param>
 public void Remove(BaseComparator value)
 {
     List.Remove(value);
 }
예제 #6
0
 /// <summary>
 /// Inserts an <see cref="BaseComparator"/> element into the <see cref="BaseComparatorCollection"/> at the specified index.
 /// </summary>
 /// <param name="index">The zero-based index at which value should be inserted.</param>
 /// <param name="value">The <see cref="BaseComparatorCollection"/> to insert.</param>
 public void Insert(int index, BaseComparator value)
 {
     List.Insert(index, value);
 }
예제 #7
0
 /// <summary>
 /// Searches for the specified <see cref="BaseComparator"/> and 
 /// returns the zero-based index of the first occurrence within the entire <see cref="BaseComparatorCollection"/>.
 /// </summary>
 /// <param name="value">The <see cref="BaseComparator"/> to locate in the <see cref="BaseComparatorCollection"/>.</param>
 /// <returns>
 /// The zero-based index of the first occurrence of value within the entire <see cref="BaseComparatorCollection"/>, 
 /// if found; otherwise, -1.
 /// </returns>
 public int IndexOf(BaseComparator value)
 {
     return (List.IndexOf(value));
 }
 /// <summary>
 /// Searches for the specified <see cref="BaseComparator"/> and
 /// returns the zero-based index of the first occurrence within the entire <see cref="BaseComparatorCollection"/>.
 /// </summary>
 /// <param name="value">The <see cref="BaseComparator"/> to locate in the <see cref="BaseComparatorCollection"/>.</param>
 /// <returns>
 /// The zero-based index of the first occurrence of value within the entire <see cref="BaseComparatorCollection"/>,
 /// if found; otherwise, -1.
 /// </returns>
 public int IndexOf(BaseComparator value)
 {
     return(List.IndexOf(value));
 }
예제 #9
0
        /// <summary>
        /// Compare the two messages.
        /// </summary>
        /// <param name="tagValueFilterCollection">Tag Value Filter.</param>
        /// <param name="resultsReporter">Results reporter.</param>
        /// <param name="thatBaseComparator">Reference comparator.</param>
        /// <returns>bool - true = messages compared, false messages not compared</returns>
        public override bool Compare(TagValueCollection tagValueFilterCollection, ResultsReporter resultsReporter, BaseComparator thatBaseComparator)
        {
            bool compared = false;

            if (thatBaseComparator is DicomComparator)
            {
                DicomComparator thatDicomComparator = (DicomComparator)thatBaseComparator;

                // Check if both templates have been initialized correctly
                if ((this.Template == null) ||
                    (thatDicomComparator.Template == null))
                {
                    return false;
                }

                // Check for comparator equality
                if (this == thatDicomComparator)
                {
                    return true;
                }

                // filter out comparators for the same message types
                if ((this.Template.Command == thatDicomComparator.Template.Command) &&
                    (this.Template.SopClassUid == thatDicomComparator.Template.SopClassUid))
                {
                    return false;
                }

                // generate a local Tag Value collection from this
                // - this collection will include any tag value pair from the original collection and
                // the tag value pairs of any tags only (in the original collection) that match from this
                // comparator - that is the values are taken from this comparator.
                TagValueCollection lTagValueFilterCollection = GenerateTagValueCollection(tagValueFilterCollection);

                // check to see if the comparision filters match - without Univeral Matching
                // - now try to match this local filter collection against thatDicomComparator
                // - comparators that match will have the same tag value pairs (including the value) as
                // each other.
                if ((tagValueFilterCollection.Count == lTagValueFilterCollection.Count) &&
                    (thatDicomComparator.UseComparator(lTagValueFilterCollection, false) == true))
                {
                    MessageComparisonResults messageComparisonResults
                        = new MessageComparisonResults(this.Name,
                        thatDicomComparator.Name,
                        this.Template.Command,
                        thatDicomComparator.Template.Command,
                        this.Template.SopClassUid,
                        thatDicomComparator.Template.SopClassUid);

                    // Iterate over this comparator
                    foreach (DicomComparisonTag thisComparisonTag in this.Template.ComparisonTags)
                    {
                        // try to get the equivalent tag in thatDicomComparator
                        DicomComparisonTag thatComparisonTag = thatDicomComparator.Template.ComparisonTags.Find(thisComparisonTag.Tag);
                        if (thatComparisonTag != null)
                        {
                            AttributeComparisonResults attributeComparisonResults
                                = new AttributeComparisonResults(thisComparisonTag.Tag,
                                thisComparisonTag.DataFormat.ToDicomFormat(),
                                thatComparisonTag.DataFormat.ToDicomFormat());

                            if (thisComparisonTag.DataFormat.Equals(thatComparisonTag.DataFormat) == false)
                            {
                                DvtkData.Validation.ValidationMessage validationMessage = new DvtkData.Validation.ValidationMessage();
                                validationMessage.Type = DvtkData.Validation.MessageType.Error;
                                validationMessage.Message = "Attribute values do not match.";

                                attributeComparisonResults.Messages.Add(validationMessage);
                            }
                            messageComparisonResults.Add(attributeComparisonResults);
                        }
                    }

                    resultsReporter.WriteMessageComparisonResults(messageComparisonResults);

                    compared = true;
                }
            }
            else if (thatBaseComparator is Hl7Comparator)
            {
                Hl7Comparator thatHl7Comparator = (Hl7Comparator)thatBaseComparator;

                // Check if both templates have been initialized correctly
                if ((this.Template == null) ||
                    (thatHl7Comparator.Template == null))
                {
                    return false;
                }

                // generate a local Tag Value collection from this
                // - this collection will include any tag value pair from the original collection and
                // the tag value pairs of any tags only (in the original collection) that match from this
                // comparator - that is the values are taken from this comparator.
                TagValueCollection lTagValueFilterCollection = GenerateTagValueCollection(tagValueFilterCollection);

                // check to see if the comparision filters match - without Univeral Matching
                // - now try to match this local filter collection against thatDicomComparator
                // - comparators that match will have the same tag value pairs (including the value) as
                // each other.
                if ((tagValueFilterCollection.Count == lTagValueFilterCollection.Count) &&
                    (thatHl7Comparator.UseComparator(lTagValueFilterCollection, false) == true))
                {
                    MessageComparisonResults messageComparisonResults
                        = new MessageComparisonResults(this.Name,
                        thatHl7Comparator.Name,
                        this.Template.Command,
                        thatHl7Comparator.Template.MessageType,
                        this.Template.SopClassUid,
                        thatHl7Comparator.Template.MessageSubType);

                    // Iterate over this comparator
                    foreach (DicomComparisonTag thisComparisonTag in this.Template.ComparisonTags)
                    {
                        // try to get the equivalent tag in thatHl7Comparator
                        Hl7ComparisonTag thatComparisonTag = thatHl7Comparator.Template.ComparisonTags.Find(DicomHl7TagMapTemplate.DicomToHl7Tag(thisComparisonTag.Tag));
                        if (thatComparisonTag != null)
                        {
                            AttributeComparisonResults attributeComparisonResults
                                = new AttributeComparisonResults(thisComparisonTag.Tag,
                                SegmentNames.Name(thatComparisonTag.Tag.Segment),
                                thatComparisonTag.Tag.FieldIndex,
                                thisComparisonTag.DataFormat.ToDicomFormat(),
                                thatComparisonTag.DataFormat.ToHl7Format());

                            if (thisComparisonTag.DataFormat.Equals(thatComparisonTag.DataFormat) == false)
                            {
                                DvtkData.Validation.ValidationMessage validationMessage = new DvtkData.Validation.ValidationMessage();
                                validationMessage.Type = DvtkData.Validation.MessageType.Error;
                                validationMessage.Message = "Attribute values do not match.";

                                attributeComparisonResults.Messages.Add(validationMessage);
                            }
                            messageComparisonResults.Add(attributeComparisonResults);
                        }
                    }

                    resultsReporter.WriteMessageComparisonResults(messageComparisonResults);

                    compared = true;
                }
            }

            return compared;
        }
예제 #10
0
 /// <summary>
 /// Compare the two messages.
 /// </summary>
 /// <param name="tagValueFilterCollection">Tag Value Filter.</param>
 /// <param name="resultsReporter">Results reporter.</param>
 /// <param name="thatBaseComparator">Reference comparator.</param>
 /// <returns>bool - true = messages compared, false messages not compared</returns>
 public abstract bool Compare(TagValueCollection tagValueFilterCollection, ResultsReporter resultsReporter, BaseComparator thatBaseComparator);
예제 #11
0
 /// <summary>
 /// Compare the two messages.
 /// </summary>
 /// <param name="resultsReporter">Results reporter.</param>
 /// <param name="thatBaseComparator">Reference comparator.</param>
 /// <returns>bool - true = messages compared, false messages not compared</returns>
 public abstract bool Compare(ResultsReporter resultsReporter, BaseComparator thatBaseComparator);
예제 #12
0
 /// <summary>
 /// Compare the two messages.
 /// </summary>
 /// <param name="tagValueFilterCollection">Tag Value Filter.</param>
 /// <param name="resultsReporter">Results reporter.</param>
 /// <param name="thatBaseComparator">Reference comparator.</param>
 /// <returns>bool - true = messages compared, false messages not compared</returns>
 public abstract bool Compare(TagValueCollection tagValueFilterCollection, ResultsReporter resultsReporter, BaseComparator thatBaseComparator);
 /// <summary>
 /// Determines whether the <see cref="BaseComparatorCollection"/> contains a specific element.
 /// </summary>
 /// <param name="value">The <see cref="BaseComparator"/> to locate in the <see cref="BaseComparatorCollection"/>.</param>
 /// <returns>
 /// <c>true</c> if the <see cref="BaseComparatorCollection"/> contains the specified value;
 /// otherwise, <c>false</c>.
 /// </returns>
 public bool Contains(BaseComparator value)
 {
     // If value is not of type Code, this will return false.
     return(List.Contains(value));
 }
 /// <summary>
 /// Removes the first occurrence of a specific <see cref="BaseComparator"/> from the <see cref="BaseComparatorCollection"/>.
 /// </summary>
 /// <param name="value">The <see cref="BaseComparator"/> to remove from the <see cref="BaseComparatorCollection"/>.</param>
 public void Remove(BaseComparator value)
 {
     List.Remove(value);
 }
 /// <summary>
 /// Inserts an <see cref="BaseComparator"/> element into the <see cref="BaseComparatorCollection"/> at the specified index.
 /// </summary>
 /// <param name="index">The zero-based index at which value should be inserted.</param>
 /// <param name="value">The <see cref="BaseComparatorCollection"/> to insert.</param>
 public void Insert(int index, BaseComparator value)
 {
     List.Insert(index, value);
 }
예제 #16
0
 /// <summary>
 /// Determines whether the <see cref="BaseComparatorCollection"/> contains a specific element.
 /// </summary>
 /// <param name="value">The <see cref="BaseComparator"/> to locate in the <see cref="BaseComparatorCollection"/>.</param>
 /// <returns>
 /// <c>true</c> if the <see cref="BaseComparatorCollection"/> contains the specified value; 
 /// otherwise, <c>false</c>.
 /// </returns>
 public bool Contains(BaseComparator value)
 {
     // If value is not of type Code, this will return false.
     return (List.Contains(value));
 }
예제 #17
0
 /// <summary>
 /// Copies the elements of the <see cref="ICollection"/> to a strong-typed <c>BaseComparator[]</c>, 
 /// starting at a particular <c>BaseComparator[]</c> index.
 /// </summary>
 /// <param name="array">
 /// The one-dimensional <c>BaseComparator[]</c> that is the destination of the elements 
 /// copied from <see cref="ICollection"/>.
 /// The <c>BaseComparator[]</c> must have zero-based indexing. 
 /// </param>
 /// <param name="index">
 /// The zero-based index in array at which copying begins.
 /// </param>
 /// <remarks>
 /// Provides the strongly typed member for <see cref="ICollection"/>.
 /// </remarks>
 public void CopyTo(BaseComparator[] array, int index)
 {
     ((ICollection)this).CopyTo(array, index);
 }
예제 #18
0
 /// <summary>
 /// Compare the two messages.
 /// </summary>
 /// <param name="resultsReporter">Results reporter.</param>
 /// <param name="thatBaseComparator">Reference comparator.</param>
 /// <returns>bool - true = messages compared, false messages not compared</returns>
 public abstract bool Compare(ResultsReporter resultsReporter, BaseComparator thatBaseComparator);
 /// <summary>
 /// Adds an object to the end of the <see cref="BaseComparatorCollection"/>.
 /// </summary>
 /// <param name="value">The <see cref="BaseComparator"/> to be added to the end of the <see cref="BaseComparatorCollection"/>.</param>
 /// <returns>The <see cref="BaseComparatorCollection"/> index at which the value has been added.</returns>
 public int Add(BaseComparator value)
 {
     return(List.Add(value));
 }