internal CommandSet(DvtkData.Dimse.CommandSet dvtkDataCommandSet)
     : base(dvtkDataCommandSet)
 {
     if (dvtkDataCommandSet == null)
     {
         DvtkHighLevelInterfaceException.Throw("Parameter may not be null/Nothing.");
     }
 }

 /// <summary>
 /// Constructor that initialized this instance with a DvtkData AcceptedPresentationContextList.
 /// </summary>
 /// <param name="dvtkDataAcceptedPresentationContextList">The DvtkData AcceptedPresentationContextList.</param>
 internal PresentationContextCollection(DvtkData.Dul.AcceptedPresentationContextList dvtkDataAcceptedPresentationContextList)
 {
     foreach (DvtkData.Dul.AcceptedPresentationContext dvtkDataAcceptedPresentationContext in dvtkDataAcceptedPresentationContextList)
     {
         PresentationContext presentationContext = new PresentationContext(dvtkDataAcceptedPresentationContext);
         Add(presentationContext);
     }
 }

 /// <summary>
 /// Constructor. Encapsulates a DvtkData.Dimse.CommandSet instance.
 /// </summary>
 /// <param name="dvtkDataCommandSet">The DvtkData.Dimse.CommandSet instance to encapsulate.</param>
 internal CommandSet(DvtkData.Dimse.CommandSet dvtkDataCommandSet)
     : base(dvtkDataCommandSet)
 {
     if (dvtkDataCommandSet == null)
     {
         throw new HliException("Parameter may not be null/Nothing.");
     }
 }

 internal FileMetaInformation(DvtkData.Dimse.AttributeSet dvtkDataAttributeSet)
     : base(dvtkDataAttributeSet)
 {
     if (dvtkDataAttributeSet == null)
     {
         DvtkHighLevelInterfaceException.Throw("Parameter may not be null/Nothing.");
     }
 }

        /// <summary>
        /// Class constructor.
        /// </summary>
        /// <param name="parentSequenceTag">Parent Sequence Tag</param>
        /// <param name="tag">Comparison Tag</param>
        /// <param name="commonDataFormat">Data Format for Tag</param>
        public DicomComparisonTag(DvtkData.Dimse.Tag parentSequenceTag, 
									DvtkData.Dimse.Tag tag, 
									BaseCommonDataFormat commonDataFormat)
        {
            _parentSequenceTag = parentSequenceTag;
            _tag = tag;
            _commonDataFormat = commonDataFormat;
        }

        /// <summary>
        /// Compare two pixel attributes (i.e. attributes that have VR OB, OF or OW).
        /// </summary>
        /// <param name="attribute1">The first attribute.</param>
        /// <param name="attribute2">The second attribute.</param>
        /// <returns>Indicates if the two are equal or not.</returns>
        public static bool ComparePixelAttributes(
			DvtkData.Dimse.Attribute attribute1, 
			DvtkData.Dimse.Attribute attribute2)
        {
            bool equal = true;

            equal = MAttributeUtilities.ComparePixelAttributes(attribute1, attribute2);

            return(equal);
        }

        public System.String GetValue(DvtkData.Dimse.Tag sequenceTag, DvtkData.Dimse.Tag tag)
        {
            System.String lValue = System.String.Empty;

            if (_dicomMessage != null)
            {
                lValue = GenerateTriggers.GetValueFromMessageUsingTag(_dicomMessage, sequenceTag, tag);

            }

            return lValue;
        }

        //
        // - Constructors -
        //
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="tagSequence">The tag sequence (one or more tags seperated with an '/') of this attribue.</param>
        /// <param name="attribute">
        /// The encapsulated Attribute from the DvtkData librbary.
        /// May not be null.
        /// </param>
        public Attribute(String tagSequence, DvtkData.Dimse.Attribute dvtkDataAttribute)
        {
            this.tagSequence = tagSequence;

            if (dvtkDataAttribute == null)
            {
                // Sanity check.
                DvtkHighLevelInterfaceException.Throw("Parameter may not be null.");
            }
            else
            {
                this.dvtkDataAttribute = dvtkDataAttribute;
            }
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="tagSequence">The tag sequence of the attribute.</param>
        /// <param name="dvtkDataAttribute">The encapsulated DvtkData attribute.</param>
        /// <param name="parentAttributeSet">The AttributeSet this instance is part of.</param>
        public ValidAttribute(TagSequence tagSequence, DvtkData.Dimse.Attribute dvtkDataAttribute, AttributeSet parentAttributeSet)
        {
            // Sanity check.
            if (dvtkDataAttribute == null)
            {
                throw new ArgumentException("Internal error: dvtkDataAttribute may not be null.");
            }

            // Sanity check.
            if (parentAttributeSet == null)
            {
                throw new ArgumentException("Internal error: parentAttributeSet may not be null.");
            }

            TagSequence = tagSequence;
            this.dvtkDataAttribute = dvtkDataAttribute;
            this.parentAttributeSet = parentAttributeSet;
        }

        /// <summary>
        /// Constructor.
        /// 
        /// Use this constructor to construct the command set and data set based on the 
        /// command set and data set contained in the encapsulated DvtkData DicomMessage.
        /// </summary>
        /// <param name="dvtkDataDicomMessage">The encapsulated DvtkData DicomMessage.</param>
        internal DicomMessage(DvtkData.Dimse.DicomMessage dvtkDataDicomMessage)
        {
            // Sanity check.
            if (dvtkDataDicomMessage == null)
            {
                DvtkHighLevelInterfaceException.Throw("Parameter may not be null.");
            }

            // Create the CommandSet object.
            this.commandSet = new CommandSet(dvtkDataDicomMessage.CommandSet);

            // Create the DataSet object.
            if (dvtkDataDicomMessage.DataSet == null)
            {
                this.dataSet = new DataSet();
            }
            else
            {
                this.dataSet = new DataSet(dvtkDataDicomMessage.DataSet);
            }
        }

        /// <summary>
        /// Initialize the DicomComparator
        /// </summary>
        /// <param name="dicomMessage"></param>
        /// <returns></returns>
        /// <returns>bool - true = template initialized, false template not initialized</returns>
        public bool Initialize(DvtkData.Dimse.DicomMessage dicomMessage)
        {
            DvtkData.Dimse.DimseCommand command = dicomMessage.CommandField;
            System.String sopClassUid = System.String.Empty;

            DvtkData.Dimse.Attribute attribute = dicomMessage.CommandSet.GetAttribute(DvtkData.Dimse.Tag.AFFECTED_SOP_CLASS_UID);
            if (attribute == null)
            {
                attribute = dicomMessage.CommandSet.GetAttribute(DvtkData.Dimse.Tag.REQUESTED_SOP_CLASS_UID);
            }
            if ((attribute != null) &&
                (attribute.Length != 0))
            {
                UniqueIdentifier uniqueIdentifier = (UniqueIdentifier)attribute.DicomValue;
                sopClassUid = uniqueIdentifier.Values[0];
            }

            // Try to initialise a template
            _template = new DicomComparisonTemplate();
            bool initialized = _template.Initialize(command, sopClassUid);
            if (initialized == true)
            {
                // Load the template with the corresponding attribute values
                initialized = LoadTemplate(dicomMessage.DataSet);
            }

            return initialized;
        }

 //
 // - Constructors -
 //
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="dvtkDataReleaseRq">The encapsulated DvtkData A_RELEASE_RQ</param>
 public ReleaseRq(DvtkData.Dul.A_RELEASE_RQ dvtkDataReleaseRq)
     : base(dvtkDataReleaseRq)
 {
 }

 /// <summary>
 /// Class constructor.
 /// </summary>
 /// <param name="tag">Comparison Tag</param>
 /// <param name="vr">Tag VR.</param>
 /// <param name="commonDataFormat">Data Format for Tag</param>
 public DicomComparisonTag(DvtkData.Dimse.Tag tag, VR vr, BaseCommonDataFormat commonDataFormat)
 {
     _tag = tag;
     _vr = vr;
     _commonDataFormat = commonDataFormat;
 }

 /// <summary>
 /// Constructor to encapsulate an existing DvtkData A_ASSOCIATE_AC.
 /// </summary>
 /// <param name="dvtkDataAssociateAc">The encapsulated DvtkData A_ASSOCIATE_AC</param>
 internal AssociateAc(DvtkData.Dul.A_ASSOCIATE_AC dvtkDataAssociateAc)
     : base(dvtkDataAssociateAc)
 {
     // Do nothing.
 }

 //
 // - Constructors -
 //        
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="dvtkDataDulMessage">The encapsulated DvtkData DulMessage.</param>
 internal DulMessage(DvtkData.Dul.DulMessage dvtkDataDulMessage)
 {
     this.dvtkDataDulMessage = dvtkDataDulMessage;
 }

 private static void AddEntry(DvtkData.Dimse.Tag parent1Tag, DvtkData.Dimse.Tag parent2Tag, DvtkData.Dimse.Tag tag, System.String segment, int fieldIndex, int componentIndex, System.String name, BaseValueConvertor valueConvertor)
 {
     _dicomHl7TagMapCollection.Add(new DicomHl7TagMap(new DicomTagPath(parent1Tag, parent2Tag, tag),
         new Hl7TagPath(new Hl7Tag(segment, fieldIndex), componentIndex, name), valueConvertor));
 }

        /// <summary>
        /// Class constructor.
        /// </summary>
        /// <param name="command">DIMSE Command ID</param>
        /// <param name="sopClassUid">SOP Class UID</param>
        /// <returns>bool - true = template initialized, false template not initialized</returns>
        public bool Initialize(DvtkData.Dimse.DimseCommand command, System.String sopClassUid)
        {
            bool initialized = true;
            _command = command;
            _sopClassUid = sopClassUid;

            // Only certain templates available
            // Use command and sopClassUid to determine if we can set one up
            if ((command == DvtkData.Dimse.DimseCommand.CFINDRSP) &&
                (sopClassUid == DvtkData.Dul.AbstractSyntax.Modality_Worklist_Information_Model_FIND.UID))
            {
                // Add the comparison tags - these tags will be used to extract the values out of the
                // Dicom Dataset for comparison with other Datasets containing the same tags
                _comparisonTags.Add(new DicomComparisonTag(Tag.SPECIFIC_CHARACTER_SET, VR.CS, new CommonStringFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.ACCESSION_NUMBER, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.SCHEDULED_PROCEDURE_STEP_SEQUENCE, Tag.MODALITY, VR.CS, new CommonStringFormat()));
            //				_comparisonTags.Add(new DicomComparisonTag(Tag.REFERENCED_STUDY_SEQUENCE, VR.SQ, new CommonUidFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENTS_NAME, VR.PN, new CommonNameFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENT_ID, VR.LO, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENTS_BIRTH_DATE, VR.DA, new CommonDateFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENTS_SEX, VR.CS, new CommonStringFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.STUDY_INSTANCE_UID, VR.UI, new CommonUidFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.REQUESTED_PROCEDURE_ID, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.SCHEDULED_PROCEDURE_STEP_SEQUENCE, Tag.SCHEDULED_PROCEDURE_STEP_ID, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.REQUESTED_PROCEDURE_DESCRIPTION, VR.LO, new CommonStringFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.SCHEDULED_PROCEDURE_STEP_SEQUENCE, Tag.SCHEDULED_PROCEDURE_STEP_DESCRIPTION, VR.LO, new CommonStringFormat()));
            }
            else if (command == DvtkData.Dimse.DimseCommand.CSTORERQ)
            {
                // Add the comparison tags - these tags will be used to extract the values out of the
                // Dicom Dataset for comparison with other Datasets containing the same tags
                _comparisonTags.Add(new DicomComparisonTag(Tag.SPECIFIC_CHARACTER_SET, VR.CS, new CommonStringFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.ACCESSION_NUMBER, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.MODALITY, VR.CS, new CommonStringFormat()));
            //				_comparisonTags.Add(new DicomComparisonTag(Tag.REFERENCED_STUDY_SEQUENCE, VR.SQ, new CommonUidFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENTS_NAME, VR.PN, new CommonNameFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENT_ID, VR.LO, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENTS_BIRTH_DATE, VR.DA, new CommonDateFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENTS_SEX, VR.CS, new CommonStringFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.STUDY_INSTANCE_UID, VR.UI, new CommonUidFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.REQUEST_ATTRIBUTES_SEQUENCE, Tag.REQUESTED_PROCEDURE_ID, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.REQUEST_ATTRIBUTES_SEQUENCE, Tag.SCHEDULED_PROCEDURE_STEP_ID, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.REQUEST_ATTRIBUTES_SEQUENCE, Tag.SCHEDULED_PROCEDURE_STEP_DESCRIPTION, VR.LO, new CommonStringFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PERFORMED_PROCEDURE_STEP_ID, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PERFORMED_PROCEDURE_STEP_DESCRIPTION, VR.LO, new CommonStringFormat()));
            }
            else if ((command == DvtkData.Dimse.DimseCommand.NCREATERQ) &&
                (sopClassUid == DvtkData.Dul.AbstractSyntax.Modality_Performed_Procedure_Step.UID))
            {
                // Add the comparison tags - these tags will be used to extract the values out of the
                // Dicom Dataset for comparison with other Datasets containing the same tags
                _comparisonTags.Add(new DicomComparisonTag(Tag.SPECIFIC_CHARACTER_SET, VR.CS, new CommonStringFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.SCHEDULED_STEP_ATTRIBUTES_SEQUENCE, Tag.ACCESSION_NUMBER, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.MODALITY, VR.CS, new CommonStringFormat()));
            //				_comparisonTags.Add(new DicomComparisonTag(Tag.SCHEDULED_STEP_ATTRIBUTES_SEQUENCE, Tag.REFERENCED_STUDY_SEQUENCE, VR.SQ, new CommonUidFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENTS_NAME, VR.PN, new CommonNameFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENT_ID, VR.LO, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENTS_BIRTH_DATE, VR.DA, new CommonDateFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PATIENTS_SEX, VR.CS, new CommonStringFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.SCHEDULED_STEP_ATTRIBUTES_SEQUENCE, Tag.STUDY_INSTANCE_UID, VR.UI, new CommonUidFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.SCHEDULED_STEP_ATTRIBUTES_SEQUENCE, Tag.REQUESTED_PROCEDURE_ID, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.SCHEDULED_STEP_ATTRIBUTES_SEQUENCE, Tag.SCHEDULED_PROCEDURE_STEP_ID, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.SCHEDULED_STEP_ATTRIBUTES_SEQUENCE, Tag.REQUESTED_PROCEDURE_DESCRIPTION, VR.LO, new CommonStringFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.SCHEDULED_STEP_ATTRIBUTES_SEQUENCE, Tag.SCHEDULED_PROCEDURE_STEP_DESCRIPTION, VR.LO, new CommonStringFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PERFORMED_PROCEDURE_STEP_ID, VR.SH, new CommonIdFormat()));
                _comparisonTags.Add(new DicomComparisonTag(Tag.PERFORMED_PROCEDURE_STEP_DESCRIPTION, VR.LO, new CommonStringFormat()));
            }
            else
            {
                initialized = false;
            }

            return initialized;
        }

        private System.String GetAttributeValue(DvtkData.Dimse.Attribute attribute)
        {
            System.String attributeValue = System.String.Empty;
            if ((attribute == null) ||
                (attribute.Length == 0))
            {
                return attributeValue;
            }

            switch(attribute.ValueRepresentation)
            {
                case VR.AE:
                {
                    ApplicationEntity applicationEntity = (ApplicationEntity)attribute.DicomValue;
                    attributeValue = applicationEntity.Values[0];
                    break;
                }
                case VR.AS:
                {
                    AgeString ageString = (AgeString)attribute.DicomValue;
                    attributeValue = ageString.Values[0];
                    break;
                }
                case VR.CS:
                {
                    CodeString codeString = (CodeString)attribute.DicomValue;

                    // Temp solution for more than one value
                    for (int i = 0; i < codeString.Values.Count; i++)
                    {
                        attributeValue += (codeString.Values[i]);
                        if ((i+1) < codeString.Values.Count)
                        {
                            attributeValue += "\\";
                        }
                    }

                    break;
                }
                case VR.DA:
                {
                    Date date = (Date)attribute.DicomValue;
                    attributeValue = date.Values[0];
                    break;
                }
                case VR.DS:
                {
                    DecimalString decimalString = (DecimalString)attribute.DicomValue;
                    attributeValue = decimalString.Values[0];
                    break;
                }
                case VR.DT:
                {
                    DvtkData.Dimse.DateTime dateTime = (DvtkData.Dimse.DateTime)attribute.DicomValue;
                    attributeValue = dateTime.Values[0];
                    break;
                }
                case VR.IS:
                {
                    IntegerString integerString = (IntegerString)attribute.DicomValue;
                    attributeValue = integerString.Values[0];
                    break;
                }
                case VR.LO:
                {
                    LongString longString = (LongString)attribute.DicomValue;
                    attributeValue = longString.Values[0];
                    break;
                }
                case VR.LT:
                {
                    LongText longText = (LongText)attribute.DicomValue;
                    attributeValue = longText.Value;
                    break;
                }
                case VR.PN:
                {
                    PersonName personName = (PersonName)attribute.DicomValue;
                    attributeValue = personName.Values[0];
                    break;
                }
                case VR.SH:
                {
                    ShortString shortString = (ShortString)attribute.DicomValue;
                    attributeValue = shortString.Values[0];
                    break;
                }
                case VR.SQ:
                {
                    // Special case looking for the SOP Class UID
                    SequenceOfItems sequenceOfItems = (SequenceOfItems)attribute.DicomValue;
                    if ((sequenceOfItems != null) &&
                        (sequenceOfItems.Sequence.Count == 1))
                    {
                        // Special case looking for the SOP Class UID
                        SequenceItem item = sequenceOfItems.Sequence[0];
                        attribute = item.GetAttribute(new Tag(0x0008, 0x1150));
                        attributeValue = GetAttributeValue(attribute);
                    }
                    break;
//.........这里部分代码省略.........

        /// <summary>
        /// Initialize the DicomComparator
        /// </summary>
        /// <param name="dicomMessage"></param>
        /// <returns>bool - true = template initialized, false template not initialized</returns>
        public bool Initialize(DvtkData.Dimse.DicomMessage dicomMessage)
        {
            // Set up the comparator using the templates
            bool setUpOk = SetUp(dicomMessage);
            if (setUpOk == true)
            {
                // Load the template with the corresponding attribute values
                setUpOk = LoadTemplate(dicomMessage.DataSet);
            }

            return setUpOk;
        }

        public bool SetUp(DvtkData.Dimse.DicomMessage dicomMessage)
        {
            DvtkData.Dimse.DimseCommand command = dicomMessage.CommandField;
            System.String sopClassUid = System.String.Empty;

            // To be fixed - why is the SOP Class UID not always filled in?
            // RB: TODO
            if (command == DvtkData.Dimse.DimseCommand.CSTORERQ)
            {
                sopClassUid = "1.2.840.10008.5.1.4.1.1.7";
            }

            DvtkData.Dimse.Attribute attribute = dicomMessage.CommandSet.GetAttribute(DvtkData.Dimse.Tag.AFFECTED_SOP_CLASS_UID);
            if (attribute == null)
            {
                attribute = dicomMessage.CommandSet.GetAttribute(DvtkData.Dimse.Tag.REQUESTED_SOP_CLASS_UID);
            }
            if ((attribute != null) &&
                (attribute.Length != 0))
            {
                UniqueIdentifier uniqueIdentifier = (UniqueIdentifier)attribute.DicomValue;
                sopClassUid = uniqueIdentifier.Values[0];
            }

            // Try to initialise a template
            _template = new DicomComparisonTemplate();
            bool setUpDone = _template.Initialize(command, sopClassUid);

            return setUpDone;
        }