Package org.hl7.fhir.dstu2.model

Class Procedure

  • All Implemented Interfaces:
    ca.uhn.fhir.model.api.IElement, Serializable, org.hl7.fhir.instance.model.api.IAnyResource, org.hl7.fhir.instance.model.api.IBase, org.hl7.fhir.instance.model.api.IBaseHasExtensions, org.hl7.fhir.instance.model.api.IBaseHasModifierExtensions, org.hl7.fhir.instance.model.api.IBaseResource, org.hl7.fhir.instance.model.api.IDomainResource
    public class Procedure
extends DomainResource
    An action that is or was performed on a patient. This can be a physical intervention like an operation, or less invasive like counseling or hypnotherapy.
    See Also:
    Serialized Form

    • Field Detail

      • identifier

        protected List<Identifier> identifier
        This records identifiers associated with this procedure that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate (e.g. in CDA documents, or in written / printed documentation).

      • subject

        protected Reference subject
        The person, animal or group on which the procedure was performed.

      • subjectTarget

        protected Resource subjectTarget
        The actual object that is the target of the reference (The person, animal or group on which the procedure was performed.)

      • category

        protected CodeableConcept category
        A code that classifies the procedure for searching, sorting and display purposes (e.g. "Surgical Procedure").

      • code

        protected CodeableConcept code
        The specific procedure that is performed. Use text if the exact nature of the procedure cannot be coded (e.g. "Laparoscopic Appendectomy").

      • notPerformed

        protected BooleanType notPerformed
        Set this to true if the record is saying that the procedure was NOT performed.

      • bodySite

        protected List<CodeableConcept> bodySite
        Detailed and structured anatomical location information. Multiple locations are allowed - e.g. multiple punch biopsies of a lesion.

      • reason

        protected Type reason
        The reason why the procedure was performed. This may be due to a Condition, may be coded entity of some type, or may simply be present as text.

      • performed

        protected Type performed
        The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.

      • encounter

        protected Reference encounter
        The encounter during which the procedure was performed.

      • encounterTarget

        protected Encounter encounterTarget
        The actual object that is the target of the reference (The encounter during which the procedure was performed.)

      • location

        protected Reference location
        The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.

      • locationTarget

        protected Location locationTarget
        The actual object that is the target of the reference (The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.)

      • outcome

        protected CodeableConcept outcome
        The outcome of the procedure - did it resolve reasons for the procedure being performed?

      • report

        protected List<Reference> report
        This could be a histology result, pathology report, surgical report, etc..

      • reportTarget

        protected List<DiagnosticReport> reportTarget
        The actual objects that are the target of the reference (This could be a histology result, pathology report, surgical report, etc..)

      • complication

        protected List<CodeableConcept> complication
        Any complications that occurred during the procedure, or in the immediate post-performance period. These are generally tracked separately from the notes, which will typically describe the procedure itself rather than any 'post procedure' issues.

      • followUp

        protected List<CodeableConcept> followUp
        If the procedure required specific follow up - e.g. removal of sutures. The followup may be represented as a simple note, or could potentially be more complex in which case the CarePlan resource can be used.

      • request

        protected Reference request
        A reference to a resource that contains details of the request for this procedure.

      • requestTarget

        protected Resource requestTarget
        The actual object that is the target of the reference (A reference to a resource that contains details of the request for this procedure.)

      • notes

        protected List<Annotation> notes
        Any other notes about the procedure. E.g. the operative notes.

      • used

        protected List<Reference> used
        Identifies medications, devices and any other substance used as part of the procedure.

      • usedTarget

        protected List<Resource> usedTarget
        The actual objects that are the target of the reference (Identifies medications, devices and any other substance used as part of the procedure.)

    • Method Detail

      • getIdentifier

        public List<Identifier> getIdentifier()
        Returns:
        identifier (This records identifiers associated with this procedure that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate (e.g. in CDA documents, or in written / printed documentation).)

      • addIdentifier

        public Identifier addIdentifier()
        Returns:
        identifier (This records identifiers associated with this procedure that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate (e.g. in CDA documents, or in written / printed documentation).)

      • getSubjectTarget

        public Resource getSubjectTarget()
        Returns:
        subject The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The person, animal or group on which the procedure was performed.)

      • setSubjectTarget

        public Procedure setSubjectTarget​(Resource value)
        Parameters:
        value - subject The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The person, animal or group on which the procedure was performed.)

      • getStatusElement

        public Enumeration<Procedure.ProcedureStatus> getStatusElement()
        Returns:
        status (A code specifying the state of the procedure. Generally this will be in-progress or completed state.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value

      • setStatusElement

        public Procedure setStatusElement​(Enumeration<Procedure.ProcedureStatus> value)
        Parameters:
        value - status (A code specifying the state of the procedure. Generally this will be in-progress or completed state.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value

      • getCategory

        public CodeableConcept getCategory()
        Returns:
        category (A code that classifies the procedure for searching, sorting and display purposes (e.g. "Surgical Procedure").)

      • getCode

        public CodeableConcept getCode()
        Returns:
        code (The specific procedure that is performed. Use text if the exact nature of the procedure cannot be coded (e.g. "Laparoscopic Appendectomy").)

      • hasCode

        public boolean hasCode()

      • setCode

        public Procedure setCode​(CodeableConcept value)
        Parameters:
        value - code (The specific procedure that is performed. Use text if the exact nature of the procedure cannot be coded (e.g. "Laparoscopic Appendectomy").)

      • getNotPerformedElement

        public BooleanType getNotPerformedElement()
        Returns:
        notPerformed (Set this to true if the record is saying that the procedure was NOT performed.). This is the underlying object with id, value and extensions. The accessor "getNotPerformed" gives direct access to the value

      • setNotPerformedElement

        public Procedure setNotPerformedElement​(BooleanType value)
        Parameters:
        value - notPerformed (Set this to true if the record is saying that the procedure was NOT performed.). This is the underlying object with id, value and extensions. The accessor "getNotPerformed" gives direct access to the value

      • getNotPerformed

        public boolean getNotPerformed()
        Returns:
        Set this to true if the record is saying that the procedure was NOT performed.

      • setNotPerformed

        public Procedure setNotPerformed​(boolean value)
        Parameters:
        value - Set this to true if the record is saying that the procedure was NOT performed.

      • getBodySite

        public List<CodeableConcept> getBodySite()
        Returns:
        bodySite (Detailed and structured anatomical location information. Multiple locations are allowed - e.g. multiple punch biopsies of a lesion.)

      • addBodySite

        public CodeableConcept addBodySite()
        Returns:
        bodySite (Detailed and structured anatomical location information. Multiple locations are allowed - e.g. multiple punch biopsies of a lesion.)

      • getReason

        public Type getReason()
        Returns:
        reason (The reason why the procedure was performed. This may be due to a Condition, may be coded entity of some type, or may simply be present as text.)

      • getReasonCodeableConcept

        public CodeableConcept getReasonCodeableConcept()
                                         throws org.hl7.fhir.exceptions.FHIRException
        Returns:
        reason (The reason why the procedure was performed. This may be due to a Condition, may be coded entity of some type, or may simply be present as text.)
        Throws:
        org.hl7.fhir.exceptions.FHIRException

      • getReasonReference

        public Reference getReasonReference()
                             throws org.hl7.fhir.exceptions.FHIRException
        Returns:
        reason (The reason why the procedure was performed. This may be due to a Condition, may be coded entity of some type, or may simply be present as text.)
        Throws:
        org.hl7.fhir.exceptions.FHIRException

      • setReason

        public Procedure setReason​(Type value)
        Parameters:
        value - reason (The reason why the procedure was performed. This may be due to a Condition, may be coded entity of some type, or may simply be present as text.)

      • getPerformed

        public Type getPerformed()
        Returns:
        performed (The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.)

      • getPerformedDateTimeType

        public DateTimeType getPerformedDateTimeType()
                                      throws org.hl7.fhir.exceptions.FHIRException
        Returns:
        performed (The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.)
        Throws:
        org.hl7.fhir.exceptions.FHIRException

      • getPerformedPeriod

        public Period getPerformedPeriod()
                          throws org.hl7.fhir.exceptions.FHIRException
        Returns:
        performed (The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.)
        Throws:
        org.hl7.fhir.exceptions.FHIRException

      • setPerformed

        public Procedure setPerformed​(Type value)
        Parameters:
        value - performed (The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.)

      • getEncounterTarget

        public Encounter getEncounterTarget()
        Returns:
        encounter The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The encounter during which the procedure was performed.)

      • setEncounterTarget

        public Procedure setEncounterTarget​(Encounter value)
        Parameters:
        value - encounter The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The encounter during which the procedure was performed.)

      • getLocation

        public Reference getLocation()
        Returns:
        location (The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.)

      • setLocation

        public Procedure setLocation​(Reference value)
        Parameters:
        value - location (The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.)

      • getLocationTarget

        public Location getLocationTarget()
        Returns:
        location The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.)

      • setLocationTarget

        public Procedure setLocationTarget​(Location value)
        Parameters:
        value - location The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.)

      • getReport

        public List<Reference> getReport()
        Returns:
        report (This could be a histology result, pathology report, surgical report, etc..)

      • addReport

        public Reference addReport()
        Returns:
        report (This could be a histology result, pathology report, surgical report, etc..)

      • getReportTarget

        public List<DiagnosticReport> getReportTarget()
        Returns:
        report (The actual objects that are the target of the reference. The reference library doesn't populate this, but you can use this to hold the resources if you resolvethemt. This could be a histology result, pathology report, surgical report, etc..)

      • addReportTarget

        public DiagnosticReport addReportTarget()
        Returns:
        report (Add an actual object that is the target of the reference. The reference library doesn't use these, but you can use this to hold the resources if you resolvethemt. This could be a histology result, pathology report, surgical report, etc..)

      • getComplication

        public List<CodeableConcept> getComplication()
        Returns:
        complication (Any complications that occurred during the procedure, or in the immediate post-performance period. These are generally tracked separately from the notes, which will typically describe the procedure itself rather than any 'post procedure' issues.)

      • addComplication

        public CodeableConcept addComplication()
        Returns:
        complication (Any complications that occurred during the procedure, or in the immediate post-performance period. These are generally tracked separately from the notes, which will typically describe the procedure itself rather than any 'post procedure' issues.)

      • getFollowUp

        public List<CodeableConcept> getFollowUp()
        Returns:
        followUp (If the procedure required specific follow up - e.g. removal of sutures. The followup may be represented as a simple note, or could potentially be more complex in which case the CarePlan resource can be used.)

      • addFollowUp

        public CodeableConcept addFollowUp()
        Returns:
        followUp (If the procedure required specific follow up - e.g. removal of sutures. The followup may be represented as a simple note, or could potentially be more complex in which case the CarePlan resource can be used.)

      • getRequest

        public Reference getRequest()
        Returns:
        request (A reference to a resource that contains details of the request for this procedure.)

      • setRequest

        public Procedure setRequest​(Reference value)
        Parameters:
        value - request (A reference to a resource that contains details of the request for this procedure.)

      • getRequestTarget

        public Resource getRequestTarget()
        Returns:
        request The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (A reference to a resource that contains details of the request for this procedure.)

      • setRequestTarget

        public Procedure setRequestTarget​(Resource value)
        Parameters:
        value - request The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (A reference to a resource that contains details of the request for this procedure.)

      • addNotes

        public Annotation addNotes()
        Returns:
        notes (Any other notes about the procedure. E.g. the operative notes.)

      • getUsed

        public List<Reference> getUsed()
        Returns:
        used (Identifies medications, devices and any other substance used as part of the procedure.)

      • hasUsed

        public boolean hasUsed()

      • addUsed

        public Reference addUsed()
        Returns:
        used (Identifies medications, devices and any other substance used as part of the procedure.)

      • getUsedTarget

        public List<Resource> getUsedTarget()
        Returns:
        used (The actual objects that are the target of the reference. The reference library doesn't populate this, but you can use this to hold the resources if you resolvethemt. Identifies medications, devices and any other substance used as part of the procedure.)

      • isEmpty

        public boolean isEmpty()
        Specified by:
        isEmpty in interface org.hl7.fhir.instance.model.api.IBase
        Overrides:
        isEmpty in class DomainResource