source: ruby/branches/0.5/lib/open_ehr/rm/composition/content/entry.rb@ 358

# rm::composition::content::entry
# entry module
# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109264528523_312165_346Report.html
# refs #56
include OpenEHR::RM::Composition::Content

module OpenEHR
  module RM
    module Composition
      module Content
        module Entry
          class Entry < ContentItem
            attr_reader :language, :encoding, :subject
            attr_accessor :provider, :other_participations, :workflow_id
            def initialize(args = { })
              super(args)
              self.language = args[:language]
              self.encoding = args[:encoding]
              self.subject = args[:subject]
              self.provider = args[:provider]
              self.other_participations = args[:other_participations]
              self.workflow_id = args[:workflow_id]
            end

            def language=(language)
              raise ArgumentError, 'language is mandatory' if language.nil?
              @language = language
            end

            def encoding=(encoding)
              raise ArgumentError, 'encoding is mandatory' if encoding.nil?
              @encoding = encoding
            end

            def subject=(subject)
              raise ArgumentError, 'subject is mandatory' if subject.nil?
              @subject = subject
            end

            def subject_is_self?
              return @subject.instance_of? PartySelf
            end
          end

          class AdminEntry < Entry
            attr_reader :data

            def initialize(args = { })
              super(args)
              self.data = args[:data]
            end

            def data=(data)
              raise ArgumentError, 'data are mandatory' if data.nil?
              @data = data
            end
          end
          class CareEntry < Entry
            attr_accessor :protocol, :guideline_id

            def initialize(args = { })
              super(args)
              self.protocol = args[:protocol]
              self.guideline_id = args[:guideline_id]
            end
          end

          class Observation < CareEntry
            attr_reader :data
            attr_accessor :state

            def initialize(args = { })
              super(args)
              self.data = args[:data]
              self.state = args[:state]
            end

            def data=(data)
              raise ArgumentError, 'data are mandatory' if data.nil?
              @data = data
            end
          end

          class Evaluation < CareEntry
            attr_reader :data

            def initialize(args = { })
              super(args)
              self.data = args[:data]
            end

            def data=(data)
              raise ArgumentError, 'data are mandatory' if data.nil?
              @data = data
            end
          end

          class Activity < Locatable
            attr_reader :description, :timing, :action_archetype_id

            def initialize(args = { })
              super(args)
              self.description = args[:description]
              self.timing = args[:timing]
              self.action_archetype_id = args[:action_archetype_id]
            end

            def description=(description)
              if description.nil?
                raise ArgumentError, 'description is mandatory'
              end
              @description = description
            end

            def timing=(timing)
              if timing.nil?
                raise ArgumentError, 'timing is mandatory'
              end
              @timing = timing
            end
          end

          def action_archetype_id=(action_archetype_id)
            if action_archetype_id.nil? || action_archetype_id.empty?
              raise ArgumentError, 'action_archetype_id is mandatory'
            end
            @action_archetype_id = action_archetype_id
          end

          class Action < CareEntry
            attr_reader :time, :description, :ism_transition
            attr_accessor :instruction_details
            
            def initialize(args = { })
              super(args)
              self.description = args[:description]
              self.time = args[:time]
              self.ism_transition = args[:ism_transition]
              self.instruction_details = args[:instruction_details]
            end

            def time=(time)
              if time.nil?
                raise ArgumentError, 'time is mandatory'
              end
              @time = time
            end

            def description=(description)
              if description.nil?
                raise ArgumentError, 'description is mandatory'
              end
              @description = description
            end

            def ism_transition=(ism_transition)
              if ism_transition.nil?
                raise ArgumentError
              end
              @ism_transition = ism_transition
            end
          end

          class InstructionDetails < Pathable

          end

          class IsmTransition < Pathable

          end
        end # of Entry
      end # of Content
    end # of Composition
  end # of RM
end # of OpenEHR