class HL7::Message::Segment

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

Constants

METHOD_MISSING_FOR_INITIALIZER

Attributes

element_delim[R]
item_delim[R]
segment_parent[RW]
segment_weight[R]

Public Class Methods

new(raw_segment="", delims=[]) { |self| ... } click to toggle source

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
# 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

Private Class Methods

weight(new_weight=nil) click to toggle source

DSL element to define a segment's sort weight returns the segment's current weight by default segments are sorted ascending

# File lib/segment.rb, line 178
def self.weight(new_weight=nil)
  if new_weight
    singleton.module_eval do
      @my_weight = new_weight
    end
  end

  singleton.module_eval do
    return 999 unless @my_weight
    @my_weight
  end
end

Public Instance Methods

<=>( other ) click to toggle source

sort-compare two Segments, 0 indicates equality

# 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() { |element| ... } click to toggle source

yield each element in the segment

# File lib/segment.rb, line 148
def each # :yields: element
  return unless @elements
  @elements.each { |e| yield e }
end
elements_from_segment(raw_segment) click to toggle source

Breaks the raw segment into elements

raw_segment

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

# 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?() click to toggle source
# File lib/segment.rb, line 159
def has_children?
  self.respond_to?(:children)
end
is_child_segment=(val) click to toggle source

indicate whether or not the segment has a parent

# File lib/segment.rb, line 143
def is_child_segment=(val)
  @is_child_segment = val
end
is_child_segment?() click to toggle source

return true if the segment has a parent

# File lib/segment.rb, line 138
def is_child_segment?
  (@is_child_segment ||= false)
end
length() click to toggle source

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

# File lib/segment.rb, line 154
def length
  0 unless @elements
  @elements.length
end
method_missing( sym, *args, &blk ) click to toggle source

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

Calls superclass method
# 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
to_hl7()

at the segment level there is no difference between to_s and to_hl7

Alias for: to_s
to_info() click to toggle source
# File lib/segment.rb, line 81
def to_info
  "%s: empty segment >> %s" % [ self.class.to_s, @elements.inspect ]
end
to_s() click to toggle source

output the HL7 spec version of the segment

# File lib/segment.rb, line 86
def to_s
  @elements.join( @element_delim )
end
Also aliased as: to_hl7
weight() click to toggle source

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

# File lib/segment.rb, line 133
def weight
  self.class.weight
end

Private Instance Methods

setup_delimiters(delims) click to toggle source
# File lib/segment.rb, line 168
def setup_delimiters(delims)
  delims = [ delims ].flatten

  @element_delim = ( delims.length>0 ) ? delims[0] : "|"
  @item_delim = ( delims.length>1 ) ? delims[1] : "^"
end