RoleSelectionFlags Enumeration

Summary

Flags that define how the SCP will accept/reject any role selection proposed by the SCU.

Syntax

C++/CLI

[FlagsAttribute()] 
public enum RoleSelectionFlags

public: 
   [FlagsAttribute] 
   enum class RoleSelectionFlags sealed

Members

Value	Member	Description
0x00000000	None	None
0x00000001	Disabled	Role selection is not included in the DICOM Association.
0x00000002	Enabled	Role selection is included in the DICOM Association.
0x00000004	AcceptUserRoleProposed	SCP accepts any user role proposed by the SCU.
0x00000008	AcceptProviderRoleProposed	SCP accepts any provider role proposed by the SCU.
0x0000000C	AcceptAllProposed	SCP accepts any role (user or provider) proposed by the SCU. Note that this is the logical or of AcceptUserRolePropose \| AcceptProviderRoleProposed

Remarks Role selection occurs during DICOM Association negotiation between an SCU and an SCP.

The client (SCU) optionally proposes one of four role selections for each Abstract Syntax:

Role selection not included in association
SCU only
SCP only
SCU and SCP

The SCP (DICOM server) accepts or rejects the proposal. The RoleSelectionFlags enumeration defines how the SCP will accept/reject the role selection proposed by the SCU.

If the RoleSelectionFlags.Disabled flag is set, then the SCP ignores any role selection provided by the SCU.

If the RoleSelectionFlags.Enabled flag is set, then the SCP will act on the role selection provided by the SCU, based on which of the following flags are set:

AcceptUserRoleProposed
AcceptProviderRoleProposed
AcceptAllProposed: this is equivalent to (AcceptUserRoleProposed | AcceptProviderRoleProposed)

For more information, see IRoleSelectionProvider.

Example

using Leadtools.Dicom.AddIn.Attributes; 
using Leadtools.Dicom.AddIn.Interfaces; 
using Leadtools.Dicom; 
using Leadtools.Dicom.AddIn; 
 
 
public class RoleSelectionProviderAddin : IRoleSelectionProvider 
{ 
 
   private List<string> _acceptUserProviderProposedList = new List<string>(); 
 
   public RoleSelectionProviderAddin() 
   { 
      // Storage Commitment classes 
      _acceptUserProviderProposedList.Add(DicomUidType.StorageCommitmentPullModelClass); 
      _acceptUserProviderProposedList.Add(DicomUidType.StorageCommitmentPullModelInstance); 
      _acceptUserProviderProposedList.Add(DicomUidType.StorageCommitmentPushModelClass); 
      _acceptUserProviderProposedList.Add(DicomUidType.StorageCommitmentPushModelInstance); 
 
      // Procedure Step SOP Classes 
      _acceptUserProviderProposedList.Add(DicomUidType.GeneralPurposePerformedProcedureStepSopClass); 
      _acceptUserProviderProposedList.Add(DicomUidType.GeneralPurposeScheduledProcedureStepSopClass); 
 
      // Media Creation Management Service Class 
      _acceptUserProviderProposedList.Add(DicomUidType.MediaCreationManagement); 
 
      // C-MOVE 
      _acceptUserProviderProposedList.Add(DicomUidType.PatientRootQueryMove); 
      _acceptUserProviderProposedList.Add(DicomUidType.PatientStudyQueryMove); 
      _acceptUserProviderProposedList.Add(DicomUidType.StudyRootQueryMove); 
 
      // C-GET 
      _acceptUserProviderProposedList.Add(DicomUidType.PatientRootQueryGet); 
      _acceptUserProviderProposedList.Add(DicomUidType.PatientStudyQueryGet); 
      _acceptUserProviderProposedList.Add(DicomUidType.StudyRootQueryGet); 
 
   } 
 
   public DicomClient Client 
   { 
      private get; 
      set; 
   } 
 
   public ExtendedNegotiation GetExtended(string abstractSyntax) 
   { 
      return ExtendedNegotiation.None; 
   } 
 
   public RoleSelectionFlags GetRoleSelection(string abstractSyntax) 
   { 
      RoleSelectionFlags roleSelectionFlags = RoleSelectionFlags.Disabled; 
 
      if (_acceptUserProviderProposedList.Contains(abstractSyntax)) 
      { 
         roleSelectionFlags = RoleSelectionFlags.AcceptAllProposed; 
      } 
 
      return roleSelectionFlags; 
   } 
 
   public bool IsAbstractSyntaxSupported(string abstractSyntax) 
   { 
      bool supported = _acceptUserProviderProposedList.Contains(abstractSyntax) || (abstractSyntax == DicomUidType.VerificationClass); 
      return supported;  
} 
 
   public bool IsTransferSyntaxSupported(string abstractSyntax, string transferSyntax) 
   { 
      bool supported = ( 
            transferSyntax == DicomUidType.ExplicitVRLittleEndian || 
            transferSyntax == DicomUidType.ExplicitVRBigEndian || 
            transferSyntax == DicomUidType.ImplicitVRLittleEndian 
            ); 
      return supported; 
   } 
}