Package org.hl7.fhir.dstu2.model

Class Procedure

java.lang.Object
org.hl7.fhir.dstu2.model.Base
org.hl7.fhir.dstu2.model.BaseResource
org.hl7.fhir.dstu2.model.Resource
org.hl7.fhir.dstu2.model.DomainResource
org.hl7.fhir.dstu2.model.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:

  • Field Details

    • 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.)

    • status

      protected Enumeration<Procedure.ProcedureStatus> status
      A code specifying the state of the procedure. Generally this will be in-progress or completed state.

    • 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.

    • reasonNotPerformed

      protected List<CodeableConcept> reasonNotPerformed
      A code indicating why 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.

    • performer

      protected List<Procedure.ProcedurePerformerComponent> performer
      Limited to 'real' people rather than equipment.

    • 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.

    • focalDevice

      protected List<Procedure.ProcedureFocalDeviceComponent> focalDevice
      A device that is implanted, removed or otherwise manipulated (calibration, battery replacement, fitting a prosthesis, attaching a wound-vac, etc.) as a focal portion of the Procedure.

    • 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.)

    • SP_DATE

      public static final String SP_DATE
      See Also:

    • SP_IDENTIFIER

      public static final String SP_IDENTIFIER
      See Also:

    • SP_CODE

      public static final String SP_CODE
      See Also:

    • SP_PERFORMER

      public static final String SP_PERFORMER
      See Also:

    • SP_SUBJECT

      public static final String SP_SUBJECT
      See Also:

    • SP_PATIENT

      public static final String SP_PATIENT
      See Also:

    • SP_LOCATION

      public static final String SP_LOCATION
      See Also:

    • SP_ENCOUNTER

      public static final String SP_ENCOUNTER
      See Also:

  • Constructor Details

  • Method Details

    • 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).)

    • hasIdentifier

      public boolean hasIdentifier()

    • 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).)

    • addIdentifier

      public Procedure addIdentifier(Identifier t)

    • getSubject

      public Reference getSubject()
      Returns:
      subject (The person, animal or group on which the procedure was performed.)

    • hasSubject

      public boolean hasSubject()

    • setSubject

      public Procedure setSubject(Reference value)
      Parameters:
      value - subject (The person, animal or group on which the procedure was performed.)

    • 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

    • hasStatusElement

      public boolean hasStatusElement()

    • hasStatus

      public boolean hasStatus()

    • 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

    • getStatus

      public Procedure.ProcedureStatus getStatus()
      Returns:
      A code specifying the state of the procedure. Generally this will be in-progress or completed state.

    • setStatus

      public Procedure setStatus(Procedure.ProcedureStatus value)
      Parameters:
      value - A code specifying the state of the procedure. Generally this will be in-progress or completed state.

    • getCategory

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

    • hasCategory

      public boolean hasCategory()

    • setCategory

      public Procedure setCategory(CodeableConcept value)
      Parameters:
      value - 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

    • hasNotPerformedElement

      public boolean hasNotPerformedElement()

    • hasNotPerformed

      public boolean hasNotPerformed()

    • 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.

    • getReasonNotPerformed

      public List<CodeableConcept> getReasonNotPerformed()
      Returns:
      reasonNotPerformed (A code indicating why the procedure was not performed.)

    • hasReasonNotPerformed

      public boolean hasReasonNotPerformed()

    • addReasonNotPerformed

      public CodeableConcept addReasonNotPerformed()
      Returns:
      reasonNotPerformed (A code indicating why the procedure was not performed.)

    • addReasonNotPerformed

      public Procedure addReasonNotPerformed(CodeableConcept t)

    • 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.)

    • hasBodySite

      public boolean hasBodySite()

    • addBodySite

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

    • addBodySite

      public Procedure addBodySite(CodeableConcept t)

    • 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

    • hasReasonCodeableConcept

      public boolean hasReasonCodeableConcept()

    • 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

    • hasReasonReference

      public boolean hasReasonReference()

    • hasReason

      public boolean hasReason()

    • 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.)

    • getPerformer

      public List<Procedure.ProcedurePerformerComponent> getPerformer()
      Returns:
      performer (Limited to 'real' people rather than equipment.)

    • hasPerformer

      public boolean hasPerformer()

    • addPerformer

      public Procedure.ProcedurePerformerComponent addPerformer()
      Returns:
      performer (Limited to 'real' people rather than equipment.)

    • addPerformer

      public Procedure addPerformer(Procedure.ProcedurePerformerComponent t)

    • 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

    • hasPerformedDateTimeType

      public boolean hasPerformedDateTimeType()

    • 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

    • hasPerformedPeriod

      public boolean hasPerformedPeriod()

    • hasPerformed

      public boolean hasPerformed()

    • 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.)

    • getEncounter

      public Reference getEncounter()
      Returns:
      encounter (The encounter during which the procedure was performed.)

    • hasEncounter

      public boolean hasEncounter()

    • setEncounter

      public Procedure setEncounter(Reference value)
      Parameters:
      value - encounter (The encounter during which the procedure was performed.)

    • 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.)

    • hasLocation

      public boolean hasLocation()

    • 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.)

    • getOutcome

      public CodeableConcept getOutcome()
      Returns:
      outcome (The outcome of the procedure - did it resolve reasons for the procedure being performed?)

    • hasOutcome

      public boolean hasOutcome()

    • setOutcome

      public Procedure setOutcome(CodeableConcept value)
      Parameters:
      value - outcome (The outcome of the procedure - did it resolve reasons for the procedure being performed?)

    • getReport

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

    • hasReport

      public boolean hasReport()

    • addReport

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

    • addReport

      public Procedure addReport(Reference t)

    • 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.)

    • hasComplication

      public boolean hasComplication()

    • 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.)

    • addComplication

      public Procedure addComplication(CodeableConcept t)

    • 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.)

    • hasFollowUp

      public boolean hasFollowUp()

    • 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.)

    • addFollowUp

      public Procedure addFollowUp(CodeableConcept t)

    • getRequest

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

    • hasRequest

      public boolean hasRequest()

    • 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.)

    • getNotes

      public List<Annotation> getNotes()
      Returns:
      notes (Any other notes about the procedure. E.g. the operative notes.)

    • hasNotes

      public boolean hasNotes()

    • addNotes

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

    • addNotes

      public Procedure addNotes(Annotation t)

    • getFocalDevice

      public List<Procedure.ProcedureFocalDeviceComponent> getFocalDevice()
      Returns:
      focalDevice (A device that is implanted, removed or otherwise manipulated (calibration, battery replacement, fitting a prosthesis, attaching a wound-vac, etc.) as a focal portion of the Procedure.)

    • hasFocalDevice

      public boolean hasFocalDevice()

    • addFocalDevice

      public Procedure.ProcedureFocalDeviceComponent addFocalDevice()
      Returns:
      focalDevice (A device that is implanted, removed or otherwise manipulated (calibration, battery replacement, fitting a prosthesis, attaching a wound-vac, etc.) as a focal portion of the Procedure.)

    • addFocalDevice

      public Procedure addFocalDevice(Procedure.ProcedureFocalDeviceComponent t)

    • 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.)

    • addUsed

      public Procedure addUsed(Reference t)

    • 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.)

    • listChildren

      protected void listChildren(List<Property> childrenList)
      Overrides:
      listChildren in class DomainResource

    • setProperty

      public void setProperty(String name, Base value) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      setProperty in class DomainResource
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • addChild

      public Base addChild(String name) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      addChild in class DomainResource
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • fhirType

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

    • copy

      public Procedure copy()
      Specified by:
      copy in class DomainResource

    • typedCopy

      protected Procedure typedCopy()

    • equalsDeep

      public boolean equalsDeep(Base other)
      Overrides:
      equalsDeep in class DomainResource

    • equalsShallow

      public boolean equalsShallow(Base other)
      Overrides:
      equalsShallow in class DomainResource

    • isEmpty

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

    • getResourceType

      public ResourceType getResourceType()
      Specified by:
      getResourceType in class Resource