mlDRTPlanIODBase.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------
//
// NOTE: 
// This file has been generated automatically by
//   FMEwork/ReleaseMeVis/Configuration/CodeGenerators/dcmtkToMLConverter/convertDcmtkToML.py
// using the template file
//   FMEwork/ReleaseMeVis/Configuration/CodeGenerators/dcmtkToMLConverter/MLDcmtkBaseObjectsNew/templates/DcmIODBase.h
//
// Destination project: 
//   FMEwork/ReleaseMeVis/Sources/Shared/MLDcmtkBaseObjectsNew
//
//----------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------
 
#ifndef __mlDRTPlanIODBase_H
#define __mlDRTPlanIODBase_H
 
// Local includes
#include "MLDcmtkBaseObjectsSystem.h"
#include "mlRTBase.h"
 
// ML includes
#ifndef __mlModuleIncludes_H
#include "mlModuleIncludes.h"
#endif
 
// DcmtkAccessories includes
#include <mlDcmtkAccessories.h>
#include "DcmSequenceInterfaces/mlDcmDRTPhysiciansOfRecordIdentificationSequenceInterface.h"  //DRTPhysiciansOfRecordIdentificationSequence
#include "DcmSequenceInterfaces/mlDcmDRTPhysiciansReadingStudyIdentificationSequenceInterface.h"  //DRTPhysiciansReadingStudyIdentificationSequence
#include "DcmSequenceInterfaces/mlDcmDRTProcedureCodeSequenceInterface.h"  //DRTProcedureCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedStudySequenceInterface.h"  //DRTReferencedStudySequence
#include "DcmSequenceInterfaces/mlDcmDRTReferringPhysicianIdentificationSequenceInterface.h"  //DRTReferringPhysicianIdentificationSequence
#include "DcmSequenceInterfaces/mlDcmDRTBreedRegistrationSequenceInterface.h"  //DRTBreedRegistrationSequence
#include "DcmSequenceInterfaces/mlDcmDRTDeidentificationMethodCodeSequenceInterface.h"  //DRTDeidentificationMethodCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTOtherPatientIDsSequenceInterface.h"  //DRTOtherPatientIDsSequence
#include "DcmSequenceInterfaces/mlDcmDRTPatientBreedCodeSequenceInterface.h"  //DRTPatientBreedCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTPatientSpeciesCodeSequenceInterface.h"  //DRTPatientSpeciesCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedPatientSequenceInterface.h"  //DRTReferencedPatientSequence
#include "DcmSequenceInterfaces/mlDcmDRTAdmittingDiagnosesCodeSequenceInterface.h"  //DRTAdmittingDiagnosesCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTBeamSequenceInterface.h"  //DRTBeamSequence
#include "DcmSequenceInterfaces/mlDcmDRTApplicationSetupSequenceInterface.h"  //DRTApplicationSetupSequence
#include "DcmSequenceInterfaces/mlDcmDRTSourceSequenceInterface.h"  //DRTSourceSequence
#include "DcmSequenceInterfaces/mlDcmDRTTreatmentMachineSequenceInRTBrachyApplicationSetupsModuleInterface.h"  //DRTTreatmentMachineSequenceInRTBrachyApplicationSetupsModule
#include "DcmSequenceInterfaces/mlDcmDRTFractionGroupSequenceInterface.h"  //DRTFractionGroupSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedDoseSequenceInterface.h"  //DRTReferencedDoseSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedRTPlanSequenceInRTGeneralPlanModuleInterface.h"  //DRTReferencedRTPlanSequenceInRTGeneralPlanModule
#include "DcmSequenceInterfaces/mlDcmDRTReferencedStructureSetSequenceInterface.h"  //DRTReferencedStructureSetSequence
#include "DcmSequenceInterfaces/mlDcmDRTPatientSetupSequenceInterface.h"  //DRTPatientSetupSequence
#include "DcmSequenceInterfaces/mlDcmDRTDoseReferenceSequenceInterface.h"  //DRTDoseReferenceSequence
#include "DcmSequenceInterfaces/mlDcmDRTPerformedProtocolCodeSequenceInterface.h"  //DRTPerformedProtocolCodeSequence
#include "DcmSequenceInterfaces/mlDcmDRTReferencedPerformedProcedureStepSequenceInterface.h"  //DRTReferencedPerformedProcedureStepSequence
#include "DcmSequenceInterfaces/mlDcmDRTRequestAttributesSequenceInterface.h"  //DRTRequestAttributesSequence
#include "DcmSequenceInterfaces/mlDcmDRTToleranceTableSequenceInterface.h"  //DRTToleranceTableSequence
#include "DcmSequenceInterfaces/mlDcmDRTCodingSchemeIdentificationSequenceInterface.h"  //DRTCodingSchemeIdentificationSequence
#include "DcmSequenceInterfaces/mlDcmDRTContributingEquipmentSequenceInterface.h"  //DRTContributingEquipmentSequence
#include "DcmSequenceInterfaces/mlDcmDRTDigitalSignaturesSequenceInterface.h"  //DRTDigitalSignaturesSequence
#include "DcmSequenceInterfaces/mlDcmDRTEncryptedAttributesSequenceInterface.h"  //DRTEncryptedAttributesSequence
#include "DcmSequenceInterfaces/mlDcmDRTHL7StructuredDocumentReferenceSequenceInterface.h"  //DRTHL7StructuredDocumentReferenceSequence
#include "DcmSequenceInterfaces/mlDcmDRTMACParametersSequenceInterface.h"  //DRTMACParametersSequence
#include "DcmSequenceInterfaces/mlDcmDRTOriginalAttributesSequenceInterface.h"  //DRTOriginalAttributesSequence
 
 
ML_START_NAMESPACE
 
// ------------------------------------------------------------------
// ------------------------------------------------------------------
class MLDCMTKBASEOBJECTS_EXPORT DRTPlanIODBase : public RTBase
{
public:
 
  DRTPlanIODBase();
 
  DRTPlanIODBase(DCMTree::TreePtr dicomTree):RTBase(dicomTree) { };
 
  typedef std::vector<DcmModuleType> dcmModuleTypeVec;
  typedef std::vector<DcmModuleType>::iterator dcmModuleTypeVecIter;
 
   bool containsModule(DcmModuleType moduleType) {
      dcmModuleTypeVecIter iter = find(_dcmModuleTypes.begin(), _dcmModuleTypes.end(), moduleType);
      return iter != _dcmModuleTypes.end();
    }
    
  dcmModuleTypeVec getModuleTypes() { return _dcmModuleTypes; }
 
  virtual ~DRTPlanIODBase () {}
 
  void setDcmTree(DCMTree::TreePtr dcmTree) { setMutableTree(dcmTree); }
 
  DCMTree::TreePtr getDCMTree() { return getMutableTree(); }
 
  bool isValid() { return getMutableTree() != NULL; }
 
 
    // ApprovalStatus (300e,0002) vr=CS, vm=1, type=1
    bool getApprovalStatus(std::string& parameter) const;
    bool setApprovalStatus(const std::string parameter);
    std::string getApprovalStatusVR() const { return "CS"; }
    std::string getApprovalStatusVM() const { return "1"; }
    std::string getApprovalStatusTag() const { return std::string("(300e,0002)"); }
    
    // ReviewDate (300e,0004) vr=DA, vm=1, type=2C
    bool getReviewDate(std::string& parameter) const;
    bool setReviewDate(const std::string parameter);
    std::string getReviewDateVR() const { return "DA"; }
    std::string getReviewDateVM() const { return "1"; }
    std::string getReviewDateTag() const { return std::string("(300e,0004)"); }
    
    // ReviewTime (300e,0005) vr=TM, vm=1, type=2C
    bool getReviewTime(std::string& parameter) const;
    bool setReviewTime(const std::string parameter);
    std::string getReviewTimeVR() const { return "TM"; }
    std::string getReviewTimeVM() const { return "1"; }
    std::string getReviewTimeTag() const { return std::string("(300e,0005)"); }
    
    // ReviewerName (300e,0008) vr=PN, vm=1, type=2C
    bool getReviewerName(std::string& parameter) const;
    bool setReviewerName(const std::string parameter);
    std::string getReviewerNameVR() const { return "PN"; }
    std::string getReviewerNameVM() const { return "1"; }
    std::string getReviewerNameTag() const { return std::string("(300e,0008)"); }
    
    // ClinicalTrialCoordinatingCenterName (0012,0060) vr=LO, vm=1, type=2
    bool getClinicalTrialCoordinatingCenterName(std::string& parameter) const;
    bool setClinicalTrialCoordinatingCenterName(const std::string parameter);
    std::string getClinicalTrialCoordinatingCenterNameVR() const { return "LO"; }
    std::string getClinicalTrialCoordinatingCenterNameVM() const { return "1"; }
    std::string getClinicalTrialCoordinatingCenterNameTag() const { return std::string("(0012,0060)"); }
    
    // ClinicalTrialTimePointDescription (0012,0051) vr=ST, vm=1, type=3
    bool getClinicalTrialTimePointDescription(std::string& parameter) const;
    bool setClinicalTrialTimePointDescription(const std::string parameter);
    std::string getClinicalTrialTimePointDescriptionVR() const { return "ST"; }
    std::string getClinicalTrialTimePointDescriptionVM() const { return "1"; }
    std::string getClinicalTrialTimePointDescriptionTag() const { return std::string("(0012,0051)"); }
    
    // ClinicalTrialTimePointID (0012,0050) vr=LO, vm=1, type=2
    bool getClinicalTrialTimePointID(std::string& parameter) const;
    bool setClinicalTrialTimePointID(const std::string parameter);
    std::string getClinicalTrialTimePointIDVR() const { return "LO"; }
    std::string getClinicalTrialTimePointIDVM() const { return "1"; }
    std::string getClinicalTrialTimePointIDTag() const { return std::string("(0012,0050)"); }
    
    // ClinicalTrialProtocolID (0012,0020) vr=LO, vm=1, type=1
    bool getClinicalTrialProtocolID(std::string& parameter) const;
    bool setClinicalTrialProtocolID(const std::string parameter);
    std::string getClinicalTrialProtocolIDVR() const { return "LO"; }
    std::string getClinicalTrialProtocolIDVM() const { return "1"; }
    std::string getClinicalTrialProtocolIDTag() const { return std::string("(0012,0020)"); }
    
    // ClinicalTrialProtocolName (0012,0021) vr=LO, vm=1, type=2
    bool getClinicalTrialProtocolName(std::string& parameter) const;
    bool setClinicalTrialProtocolName(const std::string parameter);
    std::string getClinicalTrialProtocolNameVR() const { return "LO"; }
    std::string getClinicalTrialProtocolNameVM() const { return "1"; }
    std::string getClinicalTrialProtocolNameTag() const { return std::string("(0012,0021)"); }
    
    // ClinicalTrialSiteID (0012,0030) vr=LO, vm=1, type=2
    bool getClinicalTrialSiteID(std::string& parameter) const;
    bool setClinicalTrialSiteID(const std::string parameter);
    std::string getClinicalTrialSiteIDVR() const { return "LO"; }
    std::string getClinicalTrialSiteIDVM() const { return "1"; }
    std::string getClinicalTrialSiteIDTag() const { return std::string("(0012,0030)"); }
    
    // ClinicalTrialSiteName (0012,0031) vr=LO, vm=1, type=2
    bool getClinicalTrialSiteName(std::string& parameter) const;
    bool setClinicalTrialSiteName(const std::string parameter);
    std::string getClinicalTrialSiteNameVR() const { return "LO"; }
    std::string getClinicalTrialSiteNameVM() const { return "1"; }
    std::string getClinicalTrialSiteNameTag() const { return std::string("(0012,0031)"); }
    
    // ClinicalTrialSponsorName (0012,0010) vr=LO, vm=1, type=1
    bool getClinicalTrialSponsorName(std::string& parameter) const;
    bool setClinicalTrialSponsorName(const std::string parameter);
    std::string getClinicalTrialSponsorNameVR() const { return "LO"; }
    std::string getClinicalTrialSponsorNameVM() const { return "1"; }
    std::string getClinicalTrialSponsorNameTag() const { return std::string("(0012,0010)"); }
    
    // ClinicalTrialSubjectID (0012,0040) vr=LO, vm=1, type=1C
    bool getClinicalTrialSubjectID(std::string& parameter) const;
    bool setClinicalTrialSubjectID(const std::string parameter);
    std::string getClinicalTrialSubjectIDVR() const { return "LO"; }
    std::string getClinicalTrialSubjectIDVM() const { return "1"; }
    std::string getClinicalTrialSubjectIDTag() const { return std::string("(0012,0040)"); }
    
    // ClinicalTrialSubjectReadingID (0012,0042) vr=LO, vm=1, type=1C
    bool getClinicalTrialSubjectReadingID(std::string& parameter) const;
    bool setClinicalTrialSubjectReadingID(const std::string parameter);
    std::string getClinicalTrialSubjectReadingIDVR() const { return "LO"; }
    std::string getClinicalTrialSubjectReadingIDVM() const { return "1"; }
    std::string getClinicalTrialSubjectReadingIDTag() const { return std::string("(0012,0042)"); }
    
    // FrameOfReferenceUID (0020,0052) vr=UI, vm=1, type=1
    bool getFrameOfReferenceUID(std::string& parameter) const;
    bool setFrameOfReferenceUID(const std::string parameter);
    std::string getFrameOfReferenceUIDVR() const { return "UI"; }
    std::string getFrameOfReferenceUIDVM() const { return "1"; }
    std::string getFrameOfReferenceUIDTag() const { return std::string("(0020,0052)"); }
    
    // PositionReferenceIndicator (0020,1040) vr=LO, vm=1, type=2
    bool getPositionReferenceIndicator(std::string& parameter) const;
    bool setPositionReferenceIndicator(const std::string parameter);
    std::string getPositionReferenceIndicatorVR() const { return "LO"; }
    std::string getPositionReferenceIndicatorVM() const { return "1"; }
    std::string getPositionReferenceIndicatorTag() const { return std::string("(0020,1040)"); }
    
    // DateOfLastCalibration (0018,1200) vr=DA, vm=1-n, type=3
    bool getDateOfLastCalibration(std::string& parameter) const;
    bool setDateOfLastCalibration(const std::string parameter);
    std::string getDateOfLastCalibrationVR() const { return "DA"; }
    std::string getDateOfLastCalibrationVM() const { return "1-n"; }
    std::string getDateOfLastCalibrationTag() const { return std::string("(0018,1200)"); }
    
    // DeviceSerialNumber (0018,1000) vr=LO, vm=1, type=3
    bool getDeviceSerialNumber(std::string& parameter) const;
    bool setDeviceSerialNumber(const std::string parameter);
    std::string getDeviceSerialNumberVR() const { return "LO"; }
    std::string getDeviceSerialNumberVM() const { return "1"; }
    std::string getDeviceSerialNumberTag() const { return std::string("(0018,1000)"); }
    
    // GantryID (0018,1008) vr=LO, vm=1, type=3
    bool getGantryID(std::string& parameter) const;
    bool setGantryID(const std::string parameter);
    std::string getGantryIDVR() const { return "LO"; }
    std::string getGantryIDVM() const { return "1"; }
    std::string getGantryIDTag() const { return std::string("(0018,1008)"); }
    
    // InstitutionAddress (0008,0081) vr=ST, vm=1, type=3
    bool getInstitutionAddress(std::string& parameter) const;
    bool setInstitutionAddress(const std::string parameter);
    std::string getInstitutionAddressVR() const { return "ST"; }
    std::string getInstitutionAddressVM() const { return "1"; }
    std::string getInstitutionAddressTag() const { return std::string("(0008,0081)"); }
    
    // InstitutionName (0008,0080) vr=LO, vm=1, type=3
    bool getInstitutionName(std::string& parameter) const;
    bool setInstitutionName(const std::string parameter);
    std::string getInstitutionNameVR() const { return "LO"; }
    std::string getInstitutionNameVM() const { return "1"; }
    std::string getInstitutionNameTag() const { return std::string("(0008,0080)"); }
    
    // InstitutionalDepartmentName (0008,1040) vr=LO, vm=1, type=3
    bool getInstitutionalDepartmentName(std::string& parameter) const;
    bool setInstitutionalDepartmentName(const std::string parameter);
    std::string getInstitutionalDepartmentNameVR() const { return "LO"; }
    std::string getInstitutionalDepartmentNameVM() const { return "1"; }
    std::string getInstitutionalDepartmentNameTag() const { return std::string("(0008,1040)"); }
    
    // Manufacturer (0008,0070) vr=LO, vm=1, type=2
    bool getManufacturer(std::string& parameter) const;
    bool setManufacturer(const std::string parameter);
    std::string getManufacturerVR() const { return "LO"; }
    std::string getManufacturerVM() const { return "1"; }
    std::string getManufacturerTag() const { return std::string("(0008,0070)"); }
    
    // ManufacturerModelName (0008,1090) vr=LO, vm=1, type=3
    bool getManufacturerModelName(std::string& parameter) const;
    bool setManufacturerModelName(const std::string parameter);
    std::string getManufacturerModelNameVR() const { return "LO"; }
    std::string getManufacturerModelNameVM() const { return "1"; }
    std::string getManufacturerModelNameTag() const { return std::string("(0008,1090)"); }
    
    // PixelPaddingValue (0028,0120) vr=US_SS, vm=1, type=3
    bool getPixelPaddingValue(MLuint16& parameter) const;
    bool setPixelPaddingValue(const MLuint16 parameter);
    std::string getPixelPaddingValueVR() const { return "US_SS"; }
    std::string getPixelPaddingValueVM() const { return "1"; }
    std::string getPixelPaddingValueTag() const { return std::string("(0028,0120)"); }
    
    // SoftwareVersions (0018,1020) vr=LO, vm=1-n, type=3
    bool getSoftwareVersions(std::string& parameter) const;
    bool setSoftwareVersions(const std::string parameter);
    std::string getSoftwareVersionsVR() const { return "LO"; }
    std::string getSoftwareVersionsVM() const { return "1-n"; }
    std::string getSoftwareVersionsTag() const { return std::string("(0018,1020)"); }
    
    // SpatialResolution (0018,1050) vr=DS, vm=1, type=3
    bool getSpatialResolution(std::string& parameter) const;
    bool setSpatialResolution(const std::string parameter);
    std::string getSpatialResolutionVR() const { return "DS"; }
    std::string getSpatialResolutionVM() const { return "1"; }
    std::string getSpatialResolutionTag() const { return std::string("(0018,1050)"); }
    
    // StationName (0008,1010) vr=SH, vm=1, type=3
    bool getStationName(std::string& parameter) const;
    bool setStationName(const std::string parameter);
    std::string getStationNameVR() const { return "SH"; }
    std::string getStationNameVM() const { return "1"; }
    std::string getStationNameTag() const { return std::string("(0008,1010)"); }
    
    // TimeOfLastCalibration (0018,1201) vr=TM, vm=1-n, type=3
    bool getTimeOfLastCalibration(std::string& parameter) const;
    bool setTimeOfLastCalibration(const std::string parameter);
    std::string getTimeOfLastCalibrationVR() const { return "TM"; }
    std::string getTimeOfLastCalibrationVM() const { return "1-n"; }
    std::string getTimeOfLastCalibrationTag() const { return std::string("(0018,1201)"); }
    
    // AccessionNumber (0008,0050) vr=SH, vm=1, type=2
    bool getAccessionNumber(std::string& parameter) const;
    bool setAccessionNumber(const std::string parameter);
    std::string getAccessionNumberVR() const { return "SH"; }
    std::string getAccessionNumberVM() const { return "1"; }
    std::string getAccessionNumberTag() const { return std::string("(0008,0050)"); }
    
    // NameOfPhysiciansReadingStudy (0008,1060) vr=PN, vm=1-n, type=3
    bool getNameOfPhysiciansReadingStudy(std::string& parameter) const;
    bool setNameOfPhysiciansReadingStudy(const std::string parameter);
    std::string getNameOfPhysiciansReadingStudyVR() const { return "PN"; }
    std::string getNameOfPhysiciansReadingStudyVM() const { return "1-n"; }
    std::string getNameOfPhysiciansReadingStudyTag() const { return std::string("(0008,1060)"); }
    
    // PhysiciansOfRecord (0008,1048) vr=PN, vm=1-n, type=3
    bool getPhysiciansOfRecord(std::string& parameter) const;
    bool setPhysiciansOfRecord(const std::string parameter);
    std::string getPhysiciansOfRecordVR() const { return "PN"; }
    std::string getPhysiciansOfRecordVM() const { return "1-n"; }
    std::string getPhysiciansOfRecordTag() const { return std::string("(0008,1048)"); }
    
    // ReferringPhysicianName (0008,0090) vr=PN, vm=1, type=2
    bool getReferringPhysicianName(std::string& parameter) const;
    bool setReferringPhysicianName(const std::string parameter);
    std::string getReferringPhysicianNameVR() const { return "PN"; }
    std::string getReferringPhysicianNameVM() const { return "1"; }
    std::string getReferringPhysicianNameTag() const { return std::string("(0008,0090)"); }
    
    // StudyDate (0008,0020) vr=DA, vm=1, type=2
    bool getStudyDate(std::string& parameter) const;
    bool setStudyDate(const std::string parameter);
    std::string getStudyDateVR() const { return "DA"; }
    std::string getStudyDateVM() const { return "1"; }
    std::string getStudyDateTag() const { return std::string("(0008,0020)"); }
    
    // StudyDescription (0008,1030) vr=LO, vm=1, type=3
    bool getStudyDescription(std::string& parameter) const;
    bool setStudyDescription(const std::string parameter);
    std::string getStudyDescriptionVR() const { return "LO"; }
    std::string getStudyDescriptionVM() const { return "1"; }
    std::string getStudyDescriptionTag() const { return std::string("(0008,1030)"); }
    
    // StudyID (0020,0010) vr=SH, vm=1, type=2
    bool getStudyID(std::string& parameter) const;
    bool setStudyID(const std::string parameter);
    std::string getStudyIDVR() const { return "SH"; }
    std::string getStudyIDVM() const { return "1"; }
    std::string getStudyIDTag() const { return std::string("(0020,0010)"); }
    
    // StudyInstanceUID (0020,000d) vr=UI, vm=1, type=1
    bool getStudyInstanceUID(std::string& parameter) const;
    bool setStudyInstanceUID(const std::string parameter);
    std::string getStudyInstanceUIDVR() const { return "UI"; }
    std::string getStudyInstanceUIDVM() const { return "1"; }
    std::string getStudyInstanceUIDTag() const { return std::string("(0020,000d)"); }
    
    // StudyTime (0008,0030) vr=TM, vm=1, type=2
    bool getStudyTime(std::string& parameter) const;
    bool setStudyTime(const std::string parameter);
    std::string getStudyTimeVR() const { return "TM"; }
    std::string getStudyTimeVM() const { return "1"; }
    std::string getStudyTimeTag() const { return std::string("(0008,0030)"); }
    
    // DeidentificationMethod (0012,0063) vr=LO, vm=1-n, type=1C
    bool getDeidentificationMethod(std::string& parameter) const;
    bool setDeidentificationMethod(const std::string parameter);
    std::string getDeidentificationMethodVR() const { return "LO"; }
    std::string getDeidentificationMethodVM() const { return "1-n"; }
    std::string getDeidentificationMethodTag() const { return std::string("(0012,0063)"); }
    
    // EthnicGroup (0010,2160) vr=SH, vm=1, type=3
    bool getEthnicGroup(std::string& parameter) const;
    bool setEthnicGroup(const std::string parameter);
    std::string getEthnicGroupVR() const { return "SH"; }
    std::string getEthnicGroupVM() const { return "1"; }
    std::string getEthnicGroupTag() const { return std::string("(0010,2160)"); }
    
    // IssuerOfPatientID (0010,0021) vr=LO, vm=1, type=3
    bool getIssuerOfPatientID(std::string& parameter) const;
    bool setIssuerOfPatientID(const std::string parameter);
    std::string getIssuerOfPatientIDVR() const { return "LO"; }
    std::string getIssuerOfPatientIDVM() const { return "1"; }
    std::string getIssuerOfPatientIDTag() const { return std::string("(0010,0021)"); }
    
    // OtherPatientIDs (0010,1000) vr=LO, vm=1-n, type=3
    bool getOtherPatientIDs(std::string& parameter) const;
    bool setOtherPatientIDs(const std::string parameter);
    std::string getOtherPatientIDsVR() const { return "LO"; }
    std::string getOtherPatientIDsVM() const { return "1-n"; }
    std::string getOtherPatientIDsTag() const { return std::string("(0010,1000)"); }
    
    // OtherPatientNames (0010,1001) vr=PN, vm=1-n, type=3
    bool getOtherPatientNames(std::string& parameter) const;
    bool setOtherPatientNames(const std::string parameter);
    std::string getOtherPatientNamesVR() const { return "PN"; }
    std::string getOtherPatientNamesVM() const { return "1-n"; }
    std::string getOtherPatientNamesTag() const { return std::string("(0010,1001)"); }
    
    // PatientBirthDate (0010,0030) vr=DA, vm=1, type=2
    bool getPatientBirthDate(std::string& parameter) const;
    bool setPatientBirthDate(const std::string parameter);
    std::string getPatientBirthDateVR() const { return "DA"; }
    std::string getPatientBirthDateVM() const { return "1"; }
    std::string getPatientBirthDateTag() const { return std::string("(0010,0030)"); }
    
    // PatientBirthTime (0010,0032) vr=TM, vm=1, type=3
    bool getPatientBirthTime(std::string& parameter) const;
    bool setPatientBirthTime(const std::string parameter);
    std::string getPatientBirthTimeVR() const { return "TM"; }
    std::string getPatientBirthTimeVM() const { return "1"; }
    std::string getPatientBirthTimeTag() const { return std::string("(0010,0032)"); }
    
    // PatientBreedDescription (0010,2292) vr=LO, vm=1, type=2C
    bool getPatientBreedDescription(std::string& parameter) const;
    bool setPatientBreedDescription(const std::string parameter);
    std::string getPatientBreedDescriptionVR() const { return "LO"; }
    std::string getPatientBreedDescriptionVM() const { return "1"; }
    std::string getPatientBreedDescriptionTag() const { return std::string("(0010,2292)"); }
    
    // PatientComments (0010,4000) vr=LT, vm=1, type=3
    bool getPatientComments(std::string& parameter) const;
    bool setPatientComments(const std::string parameter);
    std::string getPatientCommentsVR() const { return "LT"; }
    std::string getPatientCommentsVM() const { return "1"; }
    std::string getPatientCommentsTag() const { return std::string("(0010,4000)"); }
    
    // PatientID (0010,0020) vr=LO, vm=1, type=2
    bool getPatientID(std::string& parameter) const;
    bool setPatientID(const std::string parameter);
    std::string getPatientIDVR() const { return "LO"; }
    std::string getPatientIDVM() const { return "1"; }
    std::string getPatientIDTag() const { return std::string("(0010,0020)"); }
    
    // PatientIdentityRemoved (0012,0062) vr=CS, vm=1, type=3
    bool getPatientIdentityRemoved(std::string& parameter) const;
    bool setPatientIdentityRemoved(const std::string parameter);
    std::string getPatientIdentityRemovedVR() const { return "CS"; }
    std::string getPatientIdentityRemovedVM() const { return "1"; }
    std::string getPatientIdentityRemovedTag() const { return std::string("(0012,0062)"); }
    
    // PatientName (0010,0010) vr=PN, vm=1, type=2
    bool getPatientName(std::string& parameter) const;
    bool setPatientName(const std::string parameter);
    std::string getPatientNameVR() const { return "PN"; }
    std::string getPatientNameVM() const { return "1"; }
    std::string getPatientNameTag() const { return std::string("(0010,0010)"); }
    
    // PatientSex (0010,0040) vr=CS, vm=1, type=2
    bool getPatientSex(std::string& parameter) const;
    bool setPatientSex(const std::string parameter);
    std::string getPatientSexVR() const { return "CS"; }
    std::string getPatientSexVM() const { return "1"; }
    std::string getPatientSexTag() const { return std::string("(0010,0040)"); }
    
    // PatientSpeciesDescription (0010,2201) vr=LO, vm=1, type=1C
    bool getPatientSpeciesDescription(std::string& parameter) const;
    bool setPatientSpeciesDescription(const std::string parameter);
    std::string getPatientSpeciesDescriptionVR() const { return "LO"; }
    std::string getPatientSpeciesDescriptionVM() const { return "1"; }
    std::string getPatientSpeciesDescriptionTag() const { return std::string("(0010,2201)"); }
    
    // ResponsibleOrganization (0010,2299) vr=LO, vm=1, type=2C
    bool getResponsibleOrganization(std::string& parameter) const;
    bool setResponsibleOrganization(const std::string parameter);
    std::string getResponsibleOrganizationVR() const { return "LO"; }
    std::string getResponsibleOrganizationVM() const { return "1"; }
    std::string getResponsibleOrganizationTag() const { return std::string("(0010,2299)"); }
    
    // ResponsiblePerson (0010,2297) vr=PN, vm=1, type=2C
    bool getResponsiblePerson(std::string& parameter) const;
    bool setResponsiblePerson(const std::string parameter);
    std::string getResponsiblePersonVR() const { return "PN"; }
    std::string getResponsiblePersonVM() const { return "1"; }
    std::string getResponsiblePersonTag() const { return std::string("(0010,2297)"); }
    
    // ResponsiblePersonRole (0010,2298) vr=CS, vm=1, type=1C
    bool getResponsiblePersonRole(std::string& parameter) const;
    bool setResponsiblePersonRole(const std::string parameter);
    std::string getResponsiblePersonRoleVR() const { return "CS"; }
    std::string getResponsiblePersonRoleVM() const { return "1"; }
    std::string getResponsiblePersonRoleTag() const { return std::string("(0010,2298)"); }
    
    // AdditionalPatientHistory (0010,21b0) vr=LT, vm=1, type=3
    bool getAdditionalPatientHistory(std::string& parameter) const;
    bool setAdditionalPatientHistory(const std::string parameter);
    std::string getAdditionalPatientHistoryVR() const { return "LT"; }
    std::string getAdditionalPatientHistoryVM() const { return "1"; }
    std::string getAdditionalPatientHistoryTag() const { return std::string("(0010,21b0)"); }
    
    // AdmissionID (0038,0010) vr=LO, vm=1, type=3
    bool getAdmissionID(std::string& parameter) const;
    bool setAdmissionID(const std::string parameter);
    std::string getAdmissionIDVR() const { return "LO"; }
    std::string getAdmissionIDVM() const { return "1"; }
    std::string getAdmissionIDTag() const { return std::string("(0038,0010)"); }
    
    // AdmittingDiagnosesDescription (0008,1080) vr=LO, vm=1-n, type=3
    bool getAdmittingDiagnosesDescription(std::string& parameter) const;
    bool setAdmittingDiagnosesDescription(const std::string parameter);
    std::string getAdmittingDiagnosesDescriptionVR() const { return "LO"; }
    std::string getAdmittingDiagnosesDescriptionVM() const { return "1-n"; }
    std::string getAdmittingDiagnosesDescriptionTag() const { return std::string("(0008,1080)"); }
    
    // IssuerOfAdmissionID (0038,0011) vr=LO, vm=1, type=3
    bool getIssuerOfAdmissionID(std::string& parameter) const;
    bool setIssuerOfAdmissionID(const std::string parameter);
    std::string getIssuerOfAdmissionIDVR() const { return "LO"; }
    std::string getIssuerOfAdmissionIDVM() const { return "1"; }
    std::string getIssuerOfAdmissionIDTag() const { return std::string("(0038,0011)"); }
    
    // Occupation (0010,2180) vr=SH, vm=1, type=3
    bool getOccupation(std::string& parameter) const;
    bool setOccupation(const std::string parameter);
    std::string getOccupationVR() const { return "SH"; }
    std::string getOccupationVM() const { return "1"; }
    std::string getOccupationTag() const { return std::string("(0010,2180)"); }
    
    // PatientAge (0010,1010) vr=AS, vm=1, type=3
    bool getPatientAge(std::string& parameter) const;
    bool setPatientAge(const std::string parameter);
    std::string getPatientAgeVR() const { return "AS"; }
    std::string getPatientAgeVM() const { return "1"; }
    std::string getPatientAgeTag() const { return std::string("(0010,1010)"); }
    
    // PatientSexNeutered (0010,2203) vr=CS, vm=1, type=2C
    bool getPatientSexNeutered(std::string& parameter) const;
    bool setPatientSexNeutered(const std::string parameter);
    std::string getPatientSexNeuteredVR() const { return "CS"; }
    std::string getPatientSexNeuteredVM() const { return "1"; }
    std::string getPatientSexNeuteredTag() const { return std::string("(0010,2203)"); }
    
    // PatientSize (0010,1020) vr=DS, vm=1, type=3
    bool getPatientSize(std::string& parameter) const;
    bool setPatientSize(const std::string parameter);
    std::string getPatientSizeVR() const { return "DS"; }
    std::string getPatientSizeVM() const { return "1"; }
    std::string getPatientSizeTag() const { return std::string("(0010,1020)"); }
    
    // PatientWeight (0010,1030) vr=DS, vm=1, type=3
    bool getPatientWeight(std::string& parameter) const;
    bool setPatientWeight(const std::string parameter);
    std::string getPatientWeightVR() const { return "DS"; }
    std::string getPatientWeightVM() const { return "1"; }
    std::string getPatientWeightTag() const { return std::string("(0010,1030)"); }
    
    // BrachyTreatmentTechnique (300a,0200) vr=CS, vm=1, type=1
    bool getBrachyTreatmentTechnique(std::string& parameter) const;
    bool setBrachyTreatmentTechnique(const std::string parameter);
    std::string getBrachyTreatmentTechniqueVR() const { return "CS"; }
    std::string getBrachyTreatmentTechniqueVM() const { return "1"; }
    std::string getBrachyTreatmentTechniqueTag() const { return std::string("(300a,0200)"); }
    
    // BrachyTreatmentType (300a,0202) vr=CS, vm=1, type=1
    bool getBrachyTreatmentType(std::string& parameter) const;
    bool setBrachyTreatmentType(const std::string parameter);
    std::string getBrachyTreatmentTypeVR() const { return "CS"; }
    std::string getBrachyTreatmentTypeVM() const { return "1"; }
    std::string getBrachyTreatmentTypeTag() const { return std::string("(300a,0202)"); }
    
    // InstanceNumber (0020,0013) vr=IS, vm=1, type=3
    bool getInstanceNumber(std::string& parameter) const;
    bool setInstanceNumber(const std::string parameter);
    std::string getInstanceNumberVR() const { return "IS"; }
    std::string getInstanceNumberVM() const { return "1"; }
    std::string getInstanceNumberTag() const { return std::string("(0020,0013)"); }
    
    // OperatorsName (0008,1070) vr=PN, vm=1-n, type=2
    bool getOperatorsName(std::string& parameter) const;
    bool setOperatorsName(const std::string parameter);
    std::string getOperatorsNameVR() const { return "PN"; }
    std::string getOperatorsNameVM() const { return "1-n"; }
    std::string getOperatorsNameTag() const { return std::string("(0008,1070)"); }
    
    // PlanIntent (300a,000a) vr=CS, vm=1, type=3
    bool getPlanIntent(std::string& parameter) const;
    bool setPlanIntent(const std::string parameter);
    std::string getPlanIntentVR() const { return "CS"; }
    std::string getPlanIntentVM() const { return "1"; }
    std::string getPlanIntentTag() const { return std::string("(300a,000a)"); }
    
    // RTPlanDate (300a,0006) vr=DA, vm=1, type=2
    bool getRTPlanDate(std::string& parameter) const;
    bool setRTPlanDate(const std::string parameter);
    std::string getRTPlanDateVR() const { return "DA"; }
    std::string getRTPlanDateVM() const { return "1"; }
    std::string getRTPlanDateTag() const { return std::string("(300a,0006)"); }
    
    // RTPlanDescription (300a,0004) vr=ST, vm=1, type=3
    bool getRTPlanDescription(std::string& parameter) const;
    bool setRTPlanDescription(const std::string parameter);
    std::string getRTPlanDescriptionVR() const { return "ST"; }
    std::string getRTPlanDescriptionVM() const { return "1"; }
    std::string getRTPlanDescriptionTag() const { return std::string("(300a,0004)"); }
    
    // RTPlanGeometry (300a,000c) vr=CS, vm=1, type=1
    bool getRTPlanGeometry(std::string& parameter) const;
    bool setRTPlanGeometry(const std::string parameter);
    std::string getRTPlanGeometryVR() const { return "CS"; }
    std::string getRTPlanGeometryVM() const { return "1"; }
    std::string getRTPlanGeometryTag() const { return std::string("(300a,000c)"); }
    
    // RTPlanLabel (300a,0002) vr=SH, vm=1, type=1
    bool getRTPlanLabel(std::string& parameter) const;
    bool setRTPlanLabel(const std::string parameter);
    std::string getRTPlanLabelVR() const { return "SH"; }
    std::string getRTPlanLabelVM() const { return "1"; }
    std::string getRTPlanLabelTag() const { return std::string("(300a,0002)"); }
    
    // RTPlanName (300a,0003) vr=LO, vm=1, type=3
    bool getRTPlanName(std::string& parameter) const;
    bool setRTPlanName(const std::string parameter);
    std::string getRTPlanNameVR() const { return "LO"; }
    std::string getRTPlanNameVM() const { return "1"; }
    std::string getRTPlanNameTag() const { return std::string("(300a,0003)"); }
    
    // RTPlanTime (300a,0007) vr=TM, vm=1, type=2
    bool getRTPlanTime(std::string& parameter) const;
    bool setRTPlanTime(const std::string parameter);
    std::string getRTPlanTimeVR() const { return "TM"; }
    std::string getRTPlanTimeVM() const { return "1"; }
    std::string getRTPlanTimeTag() const { return std::string("(300a,0007)"); }
    
    // TreatmentProtocols (300a,0009) vr=LO, vm=1-n, type=3
    bool getTreatmentProtocols(std::string& parameter) const;
    bool setTreatmentProtocols(const std::string parameter);
    std::string getTreatmentProtocolsVR() const { return "LO"; }
    std::string getTreatmentProtocolsVM() const { return "1-n"; }
    std::string getTreatmentProtocolsTag() const { return std::string("(300a,0009)"); }
    
    // TreatmentSites (300a,000b) vr=LO, vm=1-n, type=3
    bool getTreatmentSites(std::string& parameter) const;
    bool setTreatmentSites(const std::string parameter);
    std::string getTreatmentSitesVR() const { return "LO"; }
    std::string getTreatmentSitesVM() const { return "1-n"; }
    std::string getTreatmentSitesTag() const { return std::string("(300a,000b)"); }
    
    // PrescriptionDescription (300a,000e) vr=ST, vm=1, type=3
    bool getPrescriptionDescription(std::string& parameter) const;
    bool setPrescriptionDescription(const std::string parameter);
    std::string getPrescriptionDescriptionVR() const { return "ST"; }
    std::string getPrescriptionDescriptionVM() const { return "1"; }
    std::string getPrescriptionDescriptionTag() const { return std::string("(300a,000e)"); }
    
    // Modality (0008,0060) vr=CS, vm=1, type=1
    bool getModality(std::string& parameter) const;
    bool setModality(const std::string parameter);
    std::string getModalityVR() const { return "CS"; }
    std::string getModalityVM() const { return "1"; }
    std::string getModalityTag() const { return std::string("(0008,0060)"); }
    
    // PerformedProcedureStepDescription (0040,0254) vr=LO, vm=1, type=3
    bool getPerformedProcedureStepDescription(std::string& parameter) const;
    bool setPerformedProcedureStepDescription(const std::string parameter);
    std::string getPerformedProcedureStepDescriptionVR() const { return "LO"; }
    std::string getPerformedProcedureStepDescriptionVM() const { return "1"; }
    std::string getPerformedProcedureStepDescriptionTag() const { return std::string("(0040,0254)"); }
    
    // PerformedProcedureStepID (0040,0253) vr=SH, vm=1, type=3
    bool getPerformedProcedureStepID(std::string& parameter) const;
    bool setPerformedProcedureStepID(const std::string parameter);
    std::string getPerformedProcedureStepIDVR() const { return "SH"; }
    std::string getPerformedProcedureStepIDVM() const { return "1"; }
    std::string getPerformedProcedureStepIDTag() const { return std::string("(0040,0253)"); }
    
    // PerformedProcedureStepStartDate (0040,0244) vr=DA, vm=1, type=3
    bool getPerformedProcedureStepStartDate(std::string& parameter) const;
    bool setPerformedProcedureStepStartDate(const std::string parameter);
    std::string getPerformedProcedureStepStartDateVR() const { return "DA"; }
    std::string getPerformedProcedureStepStartDateVM() const { return "1"; }
    std::string getPerformedProcedureStepStartDateTag() const { return std::string("(0040,0244)"); }
    
    // PerformedProcedureStepStartTime (0040,0245) vr=TM, vm=1, type=3
    bool getPerformedProcedureStepStartTime(std::string& parameter) const;
    bool setPerformedProcedureStepStartTime(const std::string parameter);
    std::string getPerformedProcedureStepStartTimeVR() const { return "TM"; }
    std::string getPerformedProcedureStepStartTimeVM() const { return "1"; }
    std::string getPerformedProcedureStepStartTimeTag() const { return std::string("(0040,0245)"); }
    
    // SeriesDescription (0008,103e) vr=LO, vm=1, type=3
    bool getSeriesDescription(std::string& parameter) const;
    bool setSeriesDescription(const std::string parameter);
    std::string getSeriesDescriptionVR() const { return "LO"; }
    std::string getSeriesDescriptionVM() const { return "1"; }
    std::string getSeriesDescriptionTag() const { return std::string("(0008,103e)"); }
    
    // SeriesInstanceUID (0020,000e) vr=UI, vm=1, type=1
    bool getSeriesInstanceUID(std::string& parameter) const;
    bool setSeriesInstanceUID(const std::string parameter);
    std::string getSeriesInstanceUIDVR() const { return "UI"; }
    std::string getSeriesInstanceUIDVM() const { return "1"; }
    std::string getSeriesInstanceUIDTag() const { return std::string("(0020,000e)"); }
    
    // SeriesNumber (0020,0011) vr=IS, vm=1, type=2
    bool getSeriesNumber(std::string& parameter) const;
    bool setSeriesNumber(const std::string parameter);
    std::string getSeriesNumberVR() const { return "IS"; }
    std::string getSeriesNumberVM() const { return "1"; }
    std::string getSeriesNumberTag() const { return std::string("(0020,0011)"); }
    
    // AuthorizationEquipmentCertificationNumber (0100,0426) vr=LO, vm=1, type=3
    bool getAuthorizationEquipmentCertificationNumber(std::string& parameter) const;
    bool setAuthorizationEquipmentCertificationNumber(const std::string parameter);
    std::string getAuthorizationEquipmentCertificationNumberVR() const { return "LO"; }
    std::string getAuthorizationEquipmentCertificationNumberVM() const { return "1"; }
    std::string getAuthorizationEquipmentCertificationNumberTag() const { return std::string("(0100,0426)"); }
    
    // InstanceCreationDate (0008,0012) vr=DA, vm=1, type=3
    bool getInstanceCreationDate(std::string& parameter) const;
    bool setInstanceCreationDate(const std::string parameter);
    std::string getInstanceCreationDateVR() const { return "DA"; }
    std::string getInstanceCreationDateVM() const { return "1"; }
    std::string getInstanceCreationDateTag() const { return std::string("(0008,0012)"); }
    
    // InstanceCreationTime (0008,0013) vr=TM, vm=1, type=3
    bool getInstanceCreationTime(std::string& parameter) const;
    bool setInstanceCreationTime(const std::string parameter);
    std::string getInstanceCreationTimeVR() const { return "TM"; }
    std::string getInstanceCreationTimeVM() const { return "1"; }
    std::string getInstanceCreationTimeTag() const { return std::string("(0008,0013)"); }
    
    // InstanceCreatorUID (0008,0014) vr=UI, vm=1, type=3
    bool getInstanceCreatorUID(std::string& parameter) const;
    bool setInstanceCreatorUID(const std::string parameter);
    std::string getInstanceCreatorUIDVR() const { return "UI"; }
    std::string getInstanceCreatorUIDVM() const { return "1"; }
    std::string getInstanceCreatorUIDTag() const { return std::string("(0008,0014)"); }
    
    // OriginalSpecializedSOPClassUID (0008,001b) vr=UI, vm=1, type=3
    bool getOriginalSpecializedSOPClassUID(std::string& parameter) const;
    bool setOriginalSpecializedSOPClassUID(const std::string parameter);
    std::string getOriginalSpecializedSOPClassUIDVR() const { return "UI"; }
    std::string getOriginalSpecializedSOPClassUIDVM() const { return "1"; }
    std::string getOriginalSpecializedSOPClassUIDTag() const { return std::string("(0008,001b)"); }
    
    // RelatedGeneralSOPClassUID (0008,001a) vr=UI, vm=1-n, type=3
    bool getRelatedGeneralSOPClassUID(std::string& parameter) const;
    bool setRelatedGeneralSOPClassUID(const std::string parameter);
    std::string getRelatedGeneralSOPClassUIDVR() const { return "UI"; }
    std::string getRelatedGeneralSOPClassUIDVM() const { return "1-n"; }
    std::string getRelatedGeneralSOPClassUIDTag() const { return std::string("(0008,001a)"); }
    
    // SOPAuthorizationComment (0100,0424) vr=LT, vm=1, type=3
    bool getSOPAuthorizationComment(std::string& parameter) const;
    bool setSOPAuthorizationComment(const std::string parameter);
    std::string getSOPAuthorizationCommentVR() const { return "LT"; }
    std::string getSOPAuthorizationCommentVM() const { return "1"; }
    std::string getSOPAuthorizationCommentTag() const { return std::string("(0100,0424)"); }
    
    // SOPAuthorizationDateTime (0100,0420) vr=DT, vm=1, type=3
    bool getSOPAuthorizationDateTime(std::string& parameter) const;
    bool setSOPAuthorizationDateTime(const std::string parameter);
    std::string getSOPAuthorizationDateTimeVR() const { return "DT"; }
    std::string getSOPAuthorizationDateTimeVM() const { return "1"; }
    std::string getSOPAuthorizationDateTimeTag() const { return std::string("(0100,0420)"); }
    
    // SOPClassUID (0008,0016) vr=UI, vm=1, type=1
    bool getSOPClassUID(std::string& parameter) const;
    bool setSOPClassUID(const std::string parameter);
    std::string getSOPClassUIDVR() const { return "UI"; }
    std::string getSOPClassUIDVM() const { return "1"; }
    std::string getSOPClassUIDTag() const { return std::string("(0008,0016)"); }
    
    // SOPInstanceStatus (0100,0410) vr=CS, vm=1, type=3
    bool getSOPInstanceStatus(std::string& parameter) const;
    bool setSOPInstanceStatus(const std::string parameter);
    std::string getSOPInstanceStatusVR() const { return "CS"; }
    std::string getSOPInstanceStatusVM() const { return "1"; }
    std::string getSOPInstanceStatusTag() const { return std::string("(0100,0410)"); }
    
    // SOPInstanceUID (0008,0018) vr=UI, vm=1, type=1
    bool getSOPInstanceUID(std::string& parameter) const;
    bool setSOPInstanceUID(const std::string parameter);
    std::string getSOPInstanceUIDVR() const { return "UI"; }
    std::string getSOPInstanceUIDVM() const { return "1"; }
    std::string getSOPInstanceUIDTag() const { return std::string("(0008,0018)"); }
    
    // SpecificCharacterSet (0008,0005) vr=CS, vm=1-n, type=1C
    bool getSpecificCharacterSet(std::string& parameter) const;
    bool setSpecificCharacterSet(const std::string parameter);
    std::string getSpecificCharacterSetVR() const { return "CS"; }
    std::string getSpecificCharacterSetVM() const { return "1-n"; }
    std::string getSpecificCharacterSetTag() const { return std::string("(0008,0005)"); }
    
    // TimezoneOffsetFromUTC (0008,0201) vr=SH, vm=1, type=3
    bool getTimezoneOffsetFromUTC(std::string& parameter) const;
    bool setTimezoneOffsetFromUTC(const std::string parameter);
    std::string getTimezoneOffsetFromUTCVR() const { return "SH"; }
    std::string getTimezoneOffsetFromUTCVM() const { return "1"; }
    std::string getTimezoneOffsetFromUTCTag() const { return std::string("(0008,0201)"); }
    
 
    // PhysiciansOfRecordIdentificationSequence (0008,1049) vr=SQ, vm=1, type=3
    virtual DcmDRTPhysiciansOfRecordIdentificationSequenceInterface getPhysiciansOfRecordIdentificationSequence();
    virtual DcmDRTPhysiciansOfRecordIdentificationSequenceInterface getEmptyPhysiciansOfRecordIdentificationSequence();
    void setPhysiciansOfRecordIdentificationSequence(DcmDRTPhysiciansOfRecordIdentificationSequenceInterface seq);
 
    std::string getPhysiciansOfRecordIdentificationSequenceVR() const { return "SQ"; }
    std::string getPhysiciansOfRecordIdentificationSequenceVM() const { return "1"; }
    std::string getPhysiciansOfRecordIdentificationSequenceTag() { return std::string("(0008,1049)"); }
 
    // PhysiciansReadingStudyIdentificationSequence (0008,1062) vr=SQ, vm=1, type=3
    virtual DcmDRTPhysiciansReadingStudyIdentificationSequenceInterface getPhysiciansReadingStudyIdentificationSequence();
    virtual DcmDRTPhysiciansReadingStudyIdentificationSequenceInterface getEmptyPhysiciansReadingStudyIdentificationSequence();
    void setPhysiciansReadingStudyIdentificationSequence(DcmDRTPhysiciansReadingStudyIdentificationSequenceInterface seq);
 
    std::string getPhysiciansReadingStudyIdentificationSequenceVR() const { return "SQ"; }
    std::string getPhysiciansReadingStudyIdentificationSequenceVM() const { return "1"; }
    std::string getPhysiciansReadingStudyIdentificationSequenceTag() { return std::string("(0008,1062)"); }
 
    // ProcedureCodeSequence (0008,1032) vr=SQ, vm=1, type=3
    virtual DcmDRTProcedureCodeSequenceInterface getProcedureCodeSequence();
    virtual DcmDRTProcedureCodeSequenceInterface getEmptyProcedureCodeSequence();
    void setProcedureCodeSequence(DcmDRTProcedureCodeSequenceInterface seq);
 
    std::string getProcedureCodeSequenceVR() const { return "SQ"; }
    std::string getProcedureCodeSequenceVM() const { return "1"; }
    std::string getProcedureCodeSequenceTag() { return std::string("(0008,1032)"); }
 
    // ReferencedStudySequence (0008,1110) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedStudySequenceInterface getReferencedStudySequence();
    virtual DcmDRTReferencedStudySequenceInterface getEmptyReferencedStudySequence();
    void setReferencedStudySequence(DcmDRTReferencedStudySequenceInterface seq);
 
    std::string getReferencedStudySequenceVR() const { return "SQ"; }
    std::string getReferencedStudySequenceVM() const { return "1"; }
    std::string getReferencedStudySequenceTag() { return std::string("(0008,1110)"); }
 
    // ReferringPhysicianIdentificationSequence (0008,0096) vr=SQ, vm=1, type=3
    virtual DcmDRTReferringPhysicianIdentificationSequenceInterface getReferringPhysicianIdentificationSequence();
    virtual DcmDRTReferringPhysicianIdentificationSequenceInterface getEmptyReferringPhysicianIdentificationSequence();
    void setReferringPhysicianIdentificationSequence(DcmDRTReferringPhysicianIdentificationSequenceInterface seq);
 
    std::string getReferringPhysicianIdentificationSequenceVR() const { return "SQ"; }
    std::string getReferringPhysicianIdentificationSequenceVM() const { return "1"; }
    std::string getReferringPhysicianIdentificationSequenceTag() { return std::string("(0008,0096)"); }
 
    // BreedRegistrationSequence (0010,2294) vr=SQ, vm=1, type=2C
    virtual DcmDRTBreedRegistrationSequenceInterface getBreedRegistrationSequence();
    virtual DcmDRTBreedRegistrationSequenceInterface getEmptyBreedRegistrationSequence();
    void setBreedRegistrationSequence(DcmDRTBreedRegistrationSequenceInterface seq);
 
    std::string getBreedRegistrationSequenceVR() const { return "SQ"; }
    std::string getBreedRegistrationSequenceVM() const { return "1"; }
    std::string getBreedRegistrationSequenceTag() { return std::string("(0010,2294)"); }
 
    // DeidentificationMethodCodeSequence (0012,0064) vr=SQ, vm=1, type=1C
    virtual DcmDRTDeidentificationMethodCodeSequenceInterface getDeidentificationMethodCodeSequence();
    virtual DcmDRTDeidentificationMethodCodeSequenceInterface getEmptyDeidentificationMethodCodeSequence();
    void setDeidentificationMethodCodeSequence(DcmDRTDeidentificationMethodCodeSequenceInterface seq);
 
    std::string getDeidentificationMethodCodeSequenceVR() const { return "SQ"; }
    std::string getDeidentificationMethodCodeSequenceVM() const { return "1"; }
    std::string getDeidentificationMethodCodeSequenceTag() { return std::string("(0012,0064)"); }
 
    // OtherPatientIDsSequence (0010,1002) vr=SQ, vm=1, type=3
    virtual DcmDRTOtherPatientIDsSequenceInterface getOtherPatientIDsSequence();
    virtual DcmDRTOtherPatientIDsSequenceInterface getEmptyOtherPatientIDsSequence();
    void setOtherPatientIDsSequence(DcmDRTOtherPatientIDsSequenceInterface seq);
 
    std::string getOtherPatientIDsSequenceVR() const { return "SQ"; }
    std::string getOtherPatientIDsSequenceVM() const { return "1"; }
    std::string getOtherPatientIDsSequenceTag() { return std::string("(0010,1002)"); }
 
    // PatientBreedCodeSequence (0010,2293) vr=SQ, vm=1, type=2C
    virtual DcmDRTPatientBreedCodeSequenceInterface getPatientBreedCodeSequence();
    virtual DcmDRTPatientBreedCodeSequenceInterface getEmptyPatientBreedCodeSequence();
    void setPatientBreedCodeSequence(DcmDRTPatientBreedCodeSequenceInterface seq);
 
    std::string getPatientBreedCodeSequenceVR() const { return "SQ"; }
    std::string getPatientBreedCodeSequenceVM() const { return "1"; }
    std::string getPatientBreedCodeSequenceTag() { return std::string("(0010,2293)"); }
 
    // PatientSpeciesCodeSequence (0010,2202) vr=SQ, vm=1, type=1C
    virtual DcmDRTPatientSpeciesCodeSequenceInterface getPatientSpeciesCodeSequence();
    virtual DcmDRTPatientSpeciesCodeSequenceInterface getEmptyPatientSpeciesCodeSequence();
    void setPatientSpeciesCodeSequence(DcmDRTPatientSpeciesCodeSequenceInterface seq);
 
    std::string getPatientSpeciesCodeSequenceVR() const { return "SQ"; }
    std::string getPatientSpeciesCodeSequenceVM() const { return "1"; }
    std::string getPatientSpeciesCodeSequenceTag() { return std::string("(0010,2202)"); }
 
    // ReferencedPatientSequence (0008,1120) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedPatientSequenceInterface getReferencedPatientSequence();
    virtual DcmDRTReferencedPatientSequenceInterface getEmptyReferencedPatientSequence();
    void setReferencedPatientSequence(DcmDRTReferencedPatientSequenceInterface seq);
 
    std::string getReferencedPatientSequenceVR() const { return "SQ"; }
    std::string getReferencedPatientSequenceVM() const { return "1"; }
    std::string getReferencedPatientSequenceTag() { return std::string("(0008,1120)"); }
 
    // AdmittingDiagnosesCodeSequence (0008,1084) vr=SQ, vm=1, type=3
    virtual DcmDRTAdmittingDiagnosesCodeSequenceInterface getAdmittingDiagnosesCodeSequence();
    virtual DcmDRTAdmittingDiagnosesCodeSequenceInterface getEmptyAdmittingDiagnosesCodeSequence();
    void setAdmittingDiagnosesCodeSequence(DcmDRTAdmittingDiagnosesCodeSequenceInterface seq);
 
    std::string getAdmittingDiagnosesCodeSequenceVR() const { return "SQ"; }
    std::string getAdmittingDiagnosesCodeSequenceVM() const { return "1"; }
    std::string getAdmittingDiagnosesCodeSequenceTag() { return std::string("(0008,1084)"); }
 
    // BeamSequence (300a,00b0) vr=SQ, vm=1, type=1
    virtual DcmDRTBeamSequenceInterface getBeamSequence();
    virtual DcmDRTBeamSequenceInterface getEmptyBeamSequence();
    void setBeamSequence(DcmDRTBeamSequenceInterface seq);
 
    std::string getBeamSequenceVR() const { return "SQ"; }
    std::string getBeamSequenceVM() const { return "1"; }
    std::string getBeamSequenceTag() { return std::string("(300a,00b0)"); }
 
    // ApplicationSetupSequence (300a,0230) vr=SQ, vm=1, type=1
    virtual DcmDRTApplicationSetupSequenceInterface getApplicationSetupSequence();
    virtual DcmDRTApplicationSetupSequenceInterface getEmptyApplicationSetupSequence();
    void setApplicationSetupSequence(DcmDRTApplicationSetupSequenceInterface seq);
 
    std::string getApplicationSetupSequenceVR() const { return "SQ"; }
    std::string getApplicationSetupSequenceVM() const { return "1"; }
    std::string getApplicationSetupSequenceTag() { return std::string("(300a,0230)"); }
 
    // SourceSequence (300a,0210) vr=SQ, vm=1, type=1
    virtual DcmDRTSourceSequenceInterface getSourceSequence();
    virtual DcmDRTSourceSequenceInterface getEmptySourceSequence();
    void setSourceSequence(DcmDRTSourceSequenceInterface seq);
 
    std::string getSourceSequenceVR() const { return "SQ"; }
    std::string getSourceSequenceVM() const { return "1"; }
    std::string getSourceSequenceTag() { return std::string("(300a,0210)"); }
 
    // TreatmentMachineSequence (300a,0206) vr=SQ, vm=1, type=1
    virtual DcmDRTTreatmentMachineSequenceInRTBrachyApplicationSetupsModuleInterface getTreatmentMachineSequence();
    virtual DcmDRTTreatmentMachineSequenceInRTBrachyApplicationSetupsModuleInterface getEmptyTreatmentMachineSequence();
    void setTreatmentMachineSequence(DcmDRTTreatmentMachineSequenceInRTBrachyApplicationSetupsModuleInterface seq);
 
    std::string getTreatmentMachineSequenceVR() const { return "SQ"; }
    std::string getTreatmentMachineSequenceVM() const { return "1"; }
    std::string getTreatmentMachineSequenceTag() { return std::string("(300a,0206)"); }
 
    // FractionGroupSequence (300a,0070) vr=SQ, vm=1, type=1
    virtual DcmDRTFractionGroupSequenceInterface getFractionGroupSequence();
    virtual DcmDRTFractionGroupSequenceInterface getEmptyFractionGroupSequence();
    void setFractionGroupSequence(DcmDRTFractionGroupSequenceInterface seq);
 
    std::string getFractionGroupSequenceVR() const { return "SQ"; }
    std::string getFractionGroupSequenceVM() const { return "1"; }
    std::string getFractionGroupSequenceTag() { return std::string("(300a,0070)"); }
 
    // ReferencedDoseSequence (300c,0080) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedDoseSequenceInterface getReferencedDoseSequence();
    virtual DcmDRTReferencedDoseSequenceInterface getEmptyReferencedDoseSequence();
    void setReferencedDoseSequence(DcmDRTReferencedDoseSequenceInterface seq);
 
    std::string getReferencedDoseSequenceVR() const { return "SQ"; }
    std::string getReferencedDoseSequenceVM() const { return "1"; }
    std::string getReferencedDoseSequenceTag() { return std::string("(300c,0080)"); }
 
    // ReferencedRTPlanSequence (300c,0002) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedRTPlanSequenceInRTGeneralPlanModuleInterface getReferencedRTPlanSequence();
    virtual DcmDRTReferencedRTPlanSequenceInRTGeneralPlanModuleInterface getEmptyReferencedRTPlanSequence();
    void setReferencedRTPlanSequence(DcmDRTReferencedRTPlanSequenceInRTGeneralPlanModuleInterface seq);
 
    std::string getReferencedRTPlanSequenceVR() const { return "SQ"; }
    std::string getReferencedRTPlanSequenceVM() const { return "1"; }
    std::string getReferencedRTPlanSequenceTag() { return std::string("(300c,0002)"); }
 
    // ReferencedStructureSetSequence (300c,0060) vr=SQ, vm=1, type=1C
    virtual DcmDRTReferencedStructureSetSequenceInterface getReferencedStructureSetSequence();
    virtual DcmDRTReferencedStructureSetSequenceInterface getEmptyReferencedStructureSetSequence();
    void setReferencedStructureSetSequence(DcmDRTReferencedStructureSetSequenceInterface seq);
 
    std::string getReferencedStructureSetSequenceVR() const { return "SQ"; }
    std::string getReferencedStructureSetSequenceVM() const { return "1"; }
    std::string getReferencedStructureSetSequenceTag() { return std::string("(300c,0060)"); }
 
    // PatientSetupSequence (300a,0180) vr=SQ, vm=1, type=1
    virtual DcmDRTPatientSetupSequenceInterface getPatientSetupSequence();
    virtual DcmDRTPatientSetupSequenceInterface getEmptyPatientSetupSequence();
    void setPatientSetupSequence(DcmDRTPatientSetupSequenceInterface seq);
 
    std::string getPatientSetupSequenceVR() const { return "SQ"; }
    std::string getPatientSetupSequenceVM() const { return "1"; }
    std::string getPatientSetupSequenceTag() { return std::string("(300a,0180)"); }
 
    // DoseReferenceSequence (300a,0010) vr=SQ, vm=1, type=3
    virtual DcmDRTDoseReferenceSequenceInterface getDoseReferenceSequence();
    virtual DcmDRTDoseReferenceSequenceInterface getEmptyDoseReferenceSequence();
    void setDoseReferenceSequence(DcmDRTDoseReferenceSequenceInterface seq);
 
    std::string getDoseReferenceSequenceVR() const { return "SQ"; }
    std::string getDoseReferenceSequenceVM() const { return "1"; }
    std::string getDoseReferenceSequenceTag() { return std::string("(300a,0010)"); }
 
    // PerformedProtocolCodeSequence (0040,0260) vr=SQ, vm=1, type=3
    virtual DcmDRTPerformedProtocolCodeSequenceInterface getPerformedProtocolCodeSequence();
    virtual DcmDRTPerformedProtocolCodeSequenceInterface getEmptyPerformedProtocolCodeSequence();
    void setPerformedProtocolCodeSequence(DcmDRTPerformedProtocolCodeSequenceInterface seq);
 
    std::string getPerformedProtocolCodeSequenceVR() const { return "SQ"; }
    std::string getPerformedProtocolCodeSequenceVM() const { return "1"; }
    std::string getPerformedProtocolCodeSequenceTag() { return std::string("(0040,0260)"); }
 
    // ReferencedPerformedProcedureStepSequence (0008,1111) vr=SQ, vm=1, type=3
    virtual DcmDRTReferencedPerformedProcedureStepSequenceInterface getReferencedPerformedProcedureStepSequence();
    virtual DcmDRTReferencedPerformedProcedureStepSequenceInterface getEmptyReferencedPerformedProcedureStepSequence();
    void setReferencedPerformedProcedureStepSequence(DcmDRTReferencedPerformedProcedureStepSequenceInterface seq);
 
    std::string getReferencedPerformedProcedureStepSequenceVR() const { return "SQ"; }
    std::string getReferencedPerformedProcedureStepSequenceVM() const { return "1"; }
    std::string getReferencedPerformedProcedureStepSequenceTag() { return std::string("(0008,1111)"); }
 
    // RequestAttributesSequence (0040,0275) vr=SQ, vm=1, type=3
    virtual DcmDRTRequestAttributesSequenceInterface getRequestAttributesSequence();
    virtual DcmDRTRequestAttributesSequenceInterface getEmptyRequestAttributesSequence();
    void setRequestAttributesSequence(DcmDRTRequestAttributesSequenceInterface seq);
 
    std::string getRequestAttributesSequenceVR() const { return "SQ"; }
    std::string getRequestAttributesSequenceVM() const { return "1"; }
    std::string getRequestAttributesSequenceTag() { return std::string("(0040,0275)"); }
 
    // ToleranceTableSequence (300a,0040) vr=SQ, vm=1, type=3
    virtual DcmDRTToleranceTableSequenceInterface getToleranceTableSequence();
    virtual DcmDRTToleranceTableSequenceInterface getEmptyToleranceTableSequence();
    void setToleranceTableSequence(DcmDRTToleranceTableSequenceInterface seq);
 
    std::string getToleranceTableSequenceVR() const { return "SQ"; }
    std::string getToleranceTableSequenceVM() const { return "1"; }
    std::string getToleranceTableSequenceTag() { return std::string("(300a,0040)"); }
 
    // CodingSchemeIdentificationSequence (0008,0110) vr=SQ, vm=1, type=3
    virtual DcmDRTCodingSchemeIdentificationSequenceInterface getCodingSchemeIdentificationSequence();
    virtual DcmDRTCodingSchemeIdentificationSequenceInterface getEmptyCodingSchemeIdentificationSequence();
    void setCodingSchemeIdentificationSequence(DcmDRTCodingSchemeIdentificationSequenceInterface seq);
 
    std::string getCodingSchemeIdentificationSequenceVR() const { return "SQ"; }
    std::string getCodingSchemeIdentificationSequenceVM() const { return "1"; }
    std::string getCodingSchemeIdentificationSequenceTag() { return std::string("(0008,0110)"); }
 
    // ContributingEquipmentSequence (0018,a001) vr=SQ, vm=1, type=3
    virtual DcmDRTContributingEquipmentSequenceInterface getContributingEquipmentSequence();
    virtual DcmDRTContributingEquipmentSequenceInterface getEmptyContributingEquipmentSequence();
    void setContributingEquipmentSequence(DcmDRTContributingEquipmentSequenceInterface seq);
 
    std::string getContributingEquipmentSequenceVR() const { return "SQ"; }
    std::string getContributingEquipmentSequenceVM() const { return "1"; }
    std::string getContributingEquipmentSequenceTag() { return std::string("(0018,a001)"); }
 
    // DigitalSignaturesSequence (fffa,fffa) vr=SQ, vm=1, type=3
    virtual DcmDRTDigitalSignaturesSequenceInterface getDigitalSignaturesSequence();
    virtual DcmDRTDigitalSignaturesSequenceInterface getEmptyDigitalSignaturesSequence();
    void setDigitalSignaturesSequence(DcmDRTDigitalSignaturesSequenceInterface seq);
 
    std::string getDigitalSignaturesSequenceVR() const { return "SQ"; }
    std::string getDigitalSignaturesSequenceVM() const { return "1"; }
    std::string getDigitalSignaturesSequenceTag() { return std::string("(fffa,fffa)"); }
 
    // EncryptedAttributesSequence (0400,0500) vr=SQ, vm=1, type=1C
    virtual DcmDRTEncryptedAttributesSequenceInterface getEncryptedAttributesSequence();
    virtual DcmDRTEncryptedAttributesSequenceInterface getEmptyEncryptedAttributesSequence();
    void setEncryptedAttributesSequence(DcmDRTEncryptedAttributesSequenceInterface seq);
 
    std::string getEncryptedAttributesSequenceVR() const { return "SQ"; }
    std::string getEncryptedAttributesSequenceVM() const { return "1"; }
    std::string getEncryptedAttributesSequenceTag() { return std::string("(0400,0500)"); }
 
    // HL7StructuredDocumentReferenceSequence (0040,a390) vr=SQ, vm=1, type=1C
    virtual DcmDRTHL7StructuredDocumentReferenceSequenceInterface getHL7StructuredDocumentReferenceSequence();
    virtual DcmDRTHL7StructuredDocumentReferenceSequenceInterface getEmptyHL7StructuredDocumentReferenceSequence();
    void setHL7StructuredDocumentReferenceSequence(DcmDRTHL7StructuredDocumentReferenceSequenceInterface seq);
 
    std::string getHL7StructuredDocumentReferenceSequenceVR() const { return "SQ"; }
    std::string getHL7StructuredDocumentReferenceSequenceVM() const { return "1"; }
    std::string getHL7StructuredDocumentReferenceSequenceTag() { return std::string("(0040,a390)"); }
 
    // MACParametersSequence (4ffe,0001) vr=SQ, vm=1, type=3
    virtual DcmDRTMACParametersSequenceInterface getMACParametersSequence();
    virtual DcmDRTMACParametersSequenceInterface getEmptyMACParametersSequence();
    void setMACParametersSequence(DcmDRTMACParametersSequenceInterface seq);
 
    std::string getMACParametersSequenceVR() const { return "SQ"; }
    std::string getMACParametersSequenceVM() const { return "1"; }
    std::string getMACParametersSequenceTag() { return std::string("(4ffe,0001)"); }
 
    // OriginalAttributesSequence (0400,0561) vr=SQ, vm=1, type=3
    virtual DcmDRTOriginalAttributesSequenceInterface getOriginalAttributesSequence();
    virtual DcmDRTOriginalAttributesSequenceInterface getEmptyOriginalAttributesSequence();
    void setOriginalAttributesSequence(DcmDRTOriginalAttributesSequenceInterface seq);
 
    std::string getOriginalAttributesSequenceVR() const { return "SQ"; }
    std::string getOriginalAttributesSequenceVM() const { return "1"; }
    std::string getOriginalAttributesSequenceTag() { return std::string("(0400,0561)"); }
 
 
 private:
  dcmModuleTypeVec _dcmModuleTypes;
  
 
  ML_CLASS_HEADER(DRTPlanIODBase)
};
 
ML_END_NAMESPACE
 
#endif // __mlDRTPlanIODBase_H
 
/* MeVis-Hidden-Components-Start */
/* MeVis-Hidden-Components-End */