Class: HL7::Message::Segment

Inherits:
Object
  • Object
show all
Extended by:
SegmentListStorage
Includes:
SegmentFields
Defined in:
lib/segment.rb

Overview

Ruby Object representation of an hl7 2.x message segment The segments can be setup to provide aliases to specific fields with optional validation code that is run when the field is modified The segment field data is also accessible via the e<number> method.

Defining a New Segment

class HL7::Message::Segment::NK1 < HL7::Message::Segment
  weight 100 # segments are sorted ascendingly
  add_field :something_you_want       # assumes :idx=>1
  add_field :something_else, :idx=>6  # :idx=>6 and field count=6
  add_field :something_more           # :idx=>7
  add_field :block_example do |value|
     raise HL7::InvalidDataError.new
                                unless value.to_i < 100 && value.to_i > 10
    return value
  end
  # this block will be executed when seg.block_example= is called
  # and when seg.block_example is called

Direct Known Subclasses

AIL, AIP, DG1, Default, ERR, EVN, FTS, IN1, MFE, MFI, MSA, MSH, NK1, NTE, OBR, OBX, ORC, ORU, PID, PRD, PV1, PV2, QRD, QRF, RF1, SCH, SFT, SPM, ZCF

Defined Under Namespace

Classes: AIL, AIP, DG1, Default, ERR, EVN, FTS, IN1, MFE, MFI, MSA, MSH, NK1, NTE, OBR, OBX, ORC, ORU, PID, PRD, PV1, PV2, QRD, QRF, RF1, SCH, SFT, SPM, ZCF

Constant Summary collapse

METHOD_MISSING_FOR_INITIALIZER = 
<<-END
  def method_missing( sym, *args, &blk )
    __seg__.send( sym, args, blk )
  end
END

Instance Attribute Summary collapse

Attributes included from SegmentListStorage

#child_types

Instance Method Summary collapse

Methods included from SegmentListStorage

add_child_type

Methods included from SegmentFields

#[], #[]=, #field_info, included, #read_field, #write_field

Constructor Details

#initialize(raw_segment = "", delims = [], &blk) ⇒ Segment

setup a new HL7::Message::Segment

raw_segment

is an optional String or Array which will be used as the segment’s field data

delims

an optional array of delimiters, where

delims[0] = element delimiter
delims[1] = item delimiter



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/segment.rb', line 41

def initialize(raw_segment="", delims=[], &blk)
  @segments_by_name = {}
  @field_total = 0
  @is_child = false

  setup_delimiters delims

  @elements = elements_from_segment(raw_segment)

  if block_given?
    callctx = eval( "self", blk.binding )
    def callctx.__seg__(val=nil)
      @__seg_val__ ||= val
    end
    callctx.__seg__(self)
    # TODO: find out if this pollutes the calling namespace permanently...

    eval( METHOD_MISSING_FOR_INITIALIZER, blk.binding )
    yield self
    eval( "class << self; remove_method :method_missing;end", blk.binding )
  end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(sym, *args, &blk) ⇒ Object

handle the e<number> field accessor and any aliases that didn’t get added to the system automatically



95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/segment.rb', line 95

def method_missing( sym, *args, &blk )
  base_str = sym.to_s.gsub( "=", "" )
  base_sym = base_str.to_sym

  if self.class.fields.include?( base_sym )
    # base_sym is ok, let's move on
  elsif /e([0-9]+)/.match( base_str )
    # base_sym should actually be $1, since we're going by
    # element id number
    base_sym = $1.to_i
  else
    super
  end

  if sym.to_s.include?( "=" )
    write_field( base_sym, args )
  else
    if args.length > 0
      write_field( base_sym, args.flatten.select { |arg| arg } )
    else
      read_field( base_sym )
    end
  end
end

Instance Attribute Details

#element_delim ⇒ Object (readonly)

Returns the value of attribute element_delim.



25
26
27
 
# File 'lib/segment.rb', line 25

def element_delim
  @element_delim
end

#item_delim ⇒ Object (readonly)

Returns the value of attribute item_delim.



26
27
28
 
# File 'lib/segment.rb', line 26

def item_delim
  @item_delim
end

#segment_parent ⇒ Object

Returns the value of attribute segment_parent.



24
25
26
 
# File 'lib/segment.rb', line 24

def segment_parent
  @segment_parent
end

#segment_weight ⇒ Object (readonly)

Returns the value of attribute segment_weight.



27
28
29
 
# File 'lib/segment.rb', line 27

def segment_weight
  @segment_weight
end

Instance Method Details

#<=>(other) ⇒ Object

sort-compare two Segments, 0 indicates equality



121
122
123
124
125
126
127
128
129
 
# File 'lib/segment.rb', line 121

def <=>( other )
  return nil unless other.kind_of?(HL7::Message::Segment)

  # per Comparable docs: http://www.ruby-doc.org/core/classes/Comparable.html
  diff = self.weight - other.weight
  return -1 if diff > 0
  return 1 if diff < 0
  return 0
end

#each ⇒ Object

yield each element in the segment



148
149
150
151
 
# File 'lib/segment.rb', line 148

def each # :yields: element
  return unless @elements
  @elements.each { |e| yield e }
end

#elements_from_segment(raw_segment) ⇒ Object

Breaks the raw segment into elements

raw_segment

is an optional String or Array which will be used as the segment’s field data



67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/segment.rb', line 67

def elements_from_segment(raw_segment)
  if (raw_segment.kind_of? Array)
    elements = raw_segment
  else
    elements = HL7::MessageParser.split_by_delimiter( raw_segment,
                                                      @element_delim )
    if raw_segment == ""
      elements[0] = self.class.to_s.split( "::" ).last
      elements << ""
    end
  end
  elements
end

#has_children? ⇒ Boolean

Returns:

  • (Boolean) 


159
160
161
 
# File 'lib/segment.rb', line 159

def has_children?
  self.respond_to?(:children)
end

#is_child_segment=(val) ⇒ Object

indicate whether or not the segment has a parent



143
144
145
 
# File 'lib/segment.rb', line 143

def is_child_segment=(val)
  @is_child_segment = val
end

#is_child_segment? ⇒ Boolean

return true if the segment has a parent

Returns:

  • (Boolean) 


138
139
140
 
# File 'lib/segment.rb', line 138

def is_child_segment?
  (@is_child_segment ||= false)
end

#length ⇒ Object

get the length of the segment (number of fields it contains)



154
155
156
157
 
# File 'lib/segment.rb', line 154

def length
  0 unless @elements
  @elements.length
end

#to_info ⇒ Object 



81
82
83
 
# File 'lib/segment.rb', line 81

def to_info
  "%s: empty segment >> %s" % [ self.class.to_s, @elements.inspect ]
end

#to_s ⇒ Object Also known as: to_hl7

output the HL7 spec version of the segment



86
87
88
 
# File 'lib/segment.rb', line 86

def to_s
  @elements.join( @element_delim )
end

#weight ⇒ Object

get the defined sort-weight of this segment class an alias for self.weight



133
134
135
 
# File 'lib/segment.rb', line 133

def weight
  self.class.weight
end