health-data-standards 3.6.1 → 3.7.0

data/lib/hqmf-parser/2.0/population_criteria.rb

@@ -2,64 +2,133 @@ module HQMF2
   # Represents an HQMF population criteria, also supports all the same methods as
   # HQMF2::Precondition
   class PopulationCriteria
-  
     include HQMF2::Utilities
-    
+
     attr_reader :preconditions, :id, :hqmf_id, :title, :aggregator, :comments
-    #need to do this to allow for setting the type to OBSERV for 
+    # need to do this to allow for setting the type to OBSERV for
     attr_accessor :type
     # Create a new population criteria from the supplied HQMF entry
     # @param [Nokogiri::XML::Element] the HQMF entry
-    def initialize(entry, doc)
+    def initialize(entry, doc, id_generator)
+      @id_generator = id_generator
       @doc = doc
       @entry = entry
-      @hqmf_id = attr_val('./*/cda:id/@extension') || attr_val('./*/cda:typeId/@extension')
-      @title = attr_val('./*/cda:code/cda:displayName/@value') 
+      setup_derived_entry_elements(id_generator)
+      # modify type to meet current expected population names
+      @type = 'IPP' if @type == 'IPOP' || @type == 'IPPOP'
+      @comments = nil if comments.empty?
+      # MEAN is handled in current code. Changed since it should have the same effect
+      @aggregator = 'MEAN' if @aggregator == 'AVERAGE'
+      @hqmf_id = @type unless @hqmf_id # The id extension is not required, if it's not provided use the code
+      handle_type(id_generator)
+    end
+
+    # Handles how the code should deal with the type definition (aggregate vs non-aggregate)
+    def handle_type(id_generator)
+      if @type != 'AGGREGATE'
+        # Generate the precondition for this population
+        if @preconditions.length > 1 ||
+           (@preconditions.length == 1 && @preconditions[0].conjunction != conjunction_code)
+          @preconditions = [Precondition.new(id_generator.next_id, conjunction_code, @preconditions)]
+        end
+      else
+        # Extract the data criteria this population references
+        dc = handle_observation_criteria
+        @preconditions = [Precondition.new(id_generator.next_id, nil, nil, false, HQMF2::Reference.new(dc.id))]
+      end
+    end
+
+    # Handles extracting elements from the entry
+    def setup_derived_entry_elements(id_generator)
+      @hqmf_id = attr_val('./*/cda:id/@root') || attr_val('./*/cda:typeId/@extension')
+      @title = attr_val('./*/cda:code/cda:displayName/@value').try(:titleize)
       @type = attr_val('./*/cda:code/@code')
-      @aggregator = nil
-      @comments = @entry.xpath("./*/cda:text/cda:xml/cda:qdmUserComments/cda:item/text()", HQMF2::Document::NAMESPACES)
-                        .map{ |v| v.content }
+      @comments = @entry.xpath('./*/cda:text/cda:xml/cda:qdmUserComments/cda:item/text()', HQMF2::Document::NAMESPACES)
+                  .map(&:content)
+      handle_preconditions(id_generator)
       obs_test = attr_val('./cda:measureObservationDefinition/@classCode')
-      if !@title && obs_test.to_s == "OBS"
-          @title = attr_val('../cda:code/cda:displayName/@value')
-          @aggregator = attr_val('./cda:measureObservationDefinition/cda:methodCode/cda:item/@code')
-      end
-      if(!@hqmf_id) # The id extension is not required, if it's not provided use the code
-        @hqmf_id = @type
+      # If there are no measure observations, or there is a title, then there are no aggregations to extract
+      return unless !@title && obs_test.to_s == 'OBS'
+      @title = attr_val('../cda:code/cda:displayName/@value')
+      @aggregator = attr_val('./cda:measureObservationDefinition/cda:methodCode/cda:item/@code')
+    end
+
+    # specifically handles extracting the preconditions for the population criteria
+    def handle_preconditions(id_generator)
+      # Nest multiple preconditions under a single root precondition
+      @preconditions = @entry.xpath('./*/cda:precondition[not(@nullFlavor)]', HQMF2::Document::NAMESPACES)
+                       .collect do |pre|
+        precondition = Precondition.parse(pre, @doc, id_generator)
+        precondition.reference.nil? && precondition.preconditions.empty? ? nil : precondition
       end
-      @preconditions = @entry.xpath('./*/cda:precondition[not(@nullFlavor)]', HQMF2::Document::NAMESPACES).collect do |precondition|
-        Precondition.new(precondition, @doc)
+      # Remove uneeded nils from the array
+      @preconditions.compact!
+    end
+
+    # extracts out any measure observation definitons, creating from them the proper criteria to generate a precondition
+    def handle_observation_criteria
+      exp = @entry.at_xpath('./cda:measureObservationDefinition/cda:value/cda:expression/@value',
+                            HQMF2::Document::NAMESPACES)
+      # Measure Observations criteria rely on computed expressions. If it doesn't have one,
+      #  then it is likely formatted improperly.
+      fail 'Measure Observations criteria is missing computed expression(s) ' if exp.nil?
+      parts = exp.to_s.split('-')
+      dc = parse_parts_to_dc(parts)
+      @doc.add_data_criteria(dc)
+      # Update reference_ids with any newly referenced data criteria
+      dc.children_criteria.each { |cc| @doc.add_reference_id(cc) } unless dc.children_criteria.nil?
+      dc
+    end
+
+    # generates the value given in an expression based on the number of criteria it references.
+    def parse_parts_to_dc(parts)
+      case parts.length
+      when 1
+        # If there is only one part, it is a reference to an existing data criteria's value
+        @doc.find_criteria_by_lvn(parts.first.strip.split('.')[0])
+      when 2
+        # If there are two parts, there is a computation performed, specifically time difference, on the two criteria
+        children = parts.collect { |p| @doc.find_criteria_by_lvn(p.strip.split('.')[0]).id }
+        id = "GROUP_TIMEDIFF_#{@id_generator.next_id}"
+        HQMF2::DataCriteriaWrapper.new(id: id,
+                                       title: id,
+                                       subset_operators: [HQMF::SubsetOperator.new('DATETIMEDIFF', nil)],
+                                       children_criteria: children,
+                                       derivation_operator: HQMF::DataCriteria::XPRODUCT,
+                                       type: 'derived',
+                                       definition: 'derived',
+                                       negation: false,
+                                       source_data_criteria: id
+                                      )
+      else
+        # If there are neither one or 2 parts, the code should fail
+        fail "No defined extraction method to handle #{parts.length} parts"
       end
     end
-    
+
     def create_human_readable_id(id)
       @id = id
     end
-    
-    # Return true of this precondition represents a conjunction with nested preconditions
-    # or false of this precondition is a reference to a data criteria
-    def conjunction?
-      true
-    end
 
-    # Get the conjunction code, e.g. allTrue, allFalse
+    # Get the conjunction code, ALL_TRUE or AT_LEAST_ONE_TRUE
     # @return [String] conjunction code
     def conjunction_code
       case @type
-      when HQMF::PopulationCriteria::IPP, HQMF::PopulationCriteria::DENOM, HQMF::PopulationCriteria::NUMER,HQMF::PopulationCriteria::MSRPOPL
+      when HQMF::PopulationCriteria::IPP, HQMF::PopulationCriteria::DENOM, HQMF::PopulationCriteria::NUMER,
+           HQMF::PopulationCriteria::MSRPOPL, HQMF::PopulationCriteria::STRAT
         HQMF::Precondition::ALL_TRUE
-      when HQMF::PopulationCriteria::DENEXCEP, HQMF::PopulationCriteria::DENEX
+      when HQMF::PopulationCriteria::DENEXCEP, HQMF::PopulationCriteria::DENEX, HQMF::PopulationCriteria::MSRPOPLEX,
+           HQMF::PopulationCriteria::NUMEX
         HQMF::Precondition::AT_LEAST_ONE_TRUE
       else
-        raise "Unknown population type [#{@type}]"
+        fail "Unknown population type [#{@type}]"
       end
     end
-    
+
+    # Generates this classes hqmf-model equivalent
     def to_model
-      mps = preconditions.collect {|p| p.to_model}
+      mps = preconditions.collect(&:to_model)
       HQMF::PopulationCriteria.new(id, hqmf_id, type, mps, title, aggregator, comments)
     end
-
   end
-  
 end

data/lib/hqmf-parser/2.0/precondition.rb

@@ -1,47 +1,73 @@
 module HQMF2
-  
+  # Represents the logic that defines grouping of criteria and actions done on it.
   class Precondition
-  
     include HQMF2::Utilities
-    
-    attr_reader :preconditions, :reference
-  
-    def initialize(entry, doc)
-      @doc = doc
-      @entry = entry
-      @preconditions = @entry.xpath('./*/cda:precondition', HQMF2::Document::NAMESPACES).collect do |precondition|
-        Precondition.new(precondition, @doc)
+
+    attr_reader :preconditions, :reference, :conjunction, :id
+
+    def self.parse(entry, doc, id_generator)
+      doc = doc
+      entry = entry
+      aggregation = entry.at_xpath('./cda:allTrue | ./cda:atLeastOneTrue | ./cda:allFalse | ./cda:atLeastOneFalse',
+                                   HQMF2::Document::NAMESPACES)
+
+      # Sets the reference criteria for the precondition (if it exists)
+      reference_def = entry.at_xpath('./*/cda:id', HQMF2::Document::NAMESPACES)
+      reference_def ||= entry.at_xpath('./cda:join/cda:templateId/cda:item', HQMF2::Document::NAMESPACES)
+      reference = Reference.new(reference_def) if reference_def
+
+      # Unless there is an aggregator, no further actions are necessary.
+      return new(id_generator.next_id, nil, [], false, reference) unless aggregation
+
+      precondition_entries = entry.xpath('./*/cda:precondition', HQMF2::Document::NAMESPACES)
+      preconditions = precondition_entries.collect do |precondition|
+        precondition = Precondition.parse(precondition, doc, id_generator)
+        # There are cases where a precondition may contain no references or preconditions, and should be ignored.
+        precondition.reference.nil? && precondition.preconditions.empty? ? nil : precondition
       end
-      reference_def = @entry.at_xpath('./*/cda:id', HQMF2::Document::NAMESPACES)
-      if !reference_def
-        reference_def = @entry.at_xpath('./cda:join/cda:templateId/cda:item', HQMF2::Document::NAMESPACES)
-      end
-      if reference_def
-        @reference = Reference.new(reference_def)
-      end
-    end
-    
-    # Return true of this precondition represents a conjunction with nested preconditions
-    # or false of this precondition is a reference to a data criteria
-    def conjunction?
-      @preconditions.length>0
+      preconditions.compact!
+      handle_aggregation(id_generator, reference, preconditions, aggregation)
     end
-    
-    # Get the conjunction code, e.g. allTrue, allFalse
-    # @return [String] conjunction code
-    def conjunction_code
-      if conjunction?
-        @entry.at_xpath('./*[1]', HQMF2::Document::NAMESPACES).name
+
+    # "False" aggregators exist, and require special handling, so this manages that and returns the
+    #   proper precondition.
+    def self.handle_aggregation(id_generator, reference, preconditions, aggregation, conjunction = nil)
+      negation = false
+      conjunction = aggregation.name
+      case conjunction
+      # DeMorgan's law is used to handle negated caes: e.g. to find if all are false, negate the "at least one true"
+      # check.
+      when 'allFalse'
+        negation = true
+        conjunction = 'atLeastOneTrue'
+      when 'atLeastOneFalse'
+        negation = true
+        conjunction = 'allTrue'
+      end
+      # Return the proper precondition given if a negation exists
+      if negation
+        # Wrap the negation in a seperate precondition which this will reference
+        precondition_wrapper = new(id_generator.next_id, conjunction, preconditions, true, reference)
+        new(id_generator.next_id, conjunction, [precondition_wrapper])
       else
-        nil
+        new(id_generator.next_id, conjunction, preconditions, false, reference)
       end
     end
-    
+
+    def initialize(id, conjunction, preconditions = [], negation = false, reference = nil)
+      @preconditions = preconditions || []
+      @conjunction = conjunction
+      @reference = reference
+      @negation = negation
+      @id = id
+    end
+
+    # Generates this classes hqmf-model equivalent
     def to_model
-      pcs = preconditions.collect {|p| p.to_model}
-      mr = reference ? reference.to_model : nil
-      HQMF::Precondition.new(nil, pcs, mr, conjunction_code, false)
+      pcs = @preconditions.collect(&:to_model)
+      mr = @reference ? @reference.to_model : nil
+      cc = @conjunction
+      HQMF::Precondition.new(@id, pcs, mr, cc, @negation)
     end
   end
-    
 end

data/lib/hqmf-parser/2.0/source_data_criteria_helper.rb

@@ -0,0 +1,112 @@
+module HQMF2
+  # Generates the Source Data Criteria from the entries in the HQMF
+  class SourceDataCriteriaHelper
+    # Generates an identifier based on the leftover elements included in the source data criteria.
+    def self.identifier(criteria)
+      sha256 = ''
+      sha256 << "#{criteria.code_list_id}:"
+      sha256 << "#{criteria.definition}:"
+      sha256 << "#{criteria.status}:"
+      sha256 << "#{criteria.specific_occurrence}:"
+      sha256 << "#{criteria.specific_occurrence_const}:"
+      sha256 << "#{criteria.variable}:"
+      sha256 << (criteria.children_criteria.nil? ? '<nil>:' : "#{criteria.children_criteria.sort.join(',')}:")
+
+      Digest::SHA256.hexdigest sha256
+    end
+
+    # Rejects any derived elements as they should never be used as source.
+    def self.should_reject?(dc)
+      dc.definition == 'derived'
+    end
+
+    # Removes unnecessary elements from a data criteria to create a source data criteria
+    def self.strip_non_sc_elements(dc)
+      if [HQMF::DataCriteria::SATISFIES_ANY, HQMF::DataCriteria::SATISFIES_ALL].include? dc.definition
+        dc.instance_variable_set(:@definition, 'derived')
+      end
+      dc.instance_variable_set(:@source_data_criteria, dc.id)
+      dc.instance_variable_set(:@field_values, {})
+      dc.instance_variable_set(:@temporal_references, [])
+      dc.instance_variable_set(:@subset_operators, [])
+      dc.instance_variable_set(:@value, nil)
+      dc.instance_variable_set(:@negation, false)
+      dc.instance_variable_set(:@negation_code_list_id, nil)
+      dc
+    end
+
+    # determins if a data criteria has any non-SDC fields set (i.e., those fields need to be stripped)
+    def self.already_stripped?(dc)
+      dc.field_values.blank? && dc.temporal_references.blank? && dc.subset_operators.blank? && dc.value.blank? && dc.negation.blank? && dc.negation_code_list_id.blank?
+    end
+
+    # Creates a data criteria based on an entry xml, removes any unnecessary elements (for the source),
+    #  and adds a data criteria reference if none exist
+    def self.as_source_data_criteria(entry, data_criteria_references = {}, occurrences_map = {})
+      dc = DataCriteria.new(entry, data_criteria_references, occurrences_map)
+      dc.original_id = dc.id
+      unless dc.definition == 'derived' # && dc.temporal_references.blank? && dc.subset_operators.blank? && dc.value.blank? && dc.field_values.blank?
+        # add "_source" to the id to differentiate from the non-source
+        dc.id = "#{dc.id}_source"
+      end
+      dc = SourceDataCriteriaHelper.strip_non_sc_elements(dc)
+      # add it as a reference
+      if dc && (data_criteria_references[dc.id].nil? || data_criteria_references[dc.id].code_list_id.nil?)
+        data_criteria_references[dc.original_id] = dc
+      end
+
+      dc
+    end
+
+    # Check if there is an existing entry in the source data criteria list that matches the candidate passed in
+    # this is used to prevent adding duplicate source data criteria entries when one already exists
+    def self.find_existing_source_data_criteria(list, candidate)
+      list.each do |sdc|
+        # check if we have an exact match on an existing SDC
+        return sdc if SourceDataCriteriaHelper.identifier(sdc) == SourceDataCriteriaHelper.identifier(candidate)
+        # we have another existing copy of the specific occurrence (identified via the constant and occurrence lettering), use that rather than duplicating... there will not be an
+        # exact match for variables since a new child will have been generated
+        return sdc if !sdc.specific_occurrence_const.nil? && sdc.specific_occurrence_const == candidate.specific_occurrence_const && sdc.specific_occurrence == candidate.specific_occurrence
+      end
+      nil
+    end
+
+    # Given a list of criteria obtained from the XML, generate most of the source data criteria (since no explicit
+    # sources are given). After generating the source data criteria, filter the list to not include repeated,
+    # unnecessary sources, but maintain and return map of those that have been removed to those that they were replaced
+    # with.
+    def self.get_source_data_criteria_list(full_criteria_list, data_criteria_references = {}, occurrences_map = {})
+      # currently, this will erase the sources if the ids are the same, but will not correct references later on
+      source_data_criteria = full_criteria_list.map do |entry|
+        SourceDataCriteriaHelper.as_source_data_criteria(entry, data_criteria_references, occurrences_map)
+      end
+
+      collapsed_source_data_criteria_map = {}
+      uniq_source_data_criteria = {}
+      source_data_criteria.each do |sdc|
+        identifier = SourceDataCriteriaHelper.identifier(sdc)
+        if uniq_source_data_criteria.key? identifier
+          collapsed_source_data_criteria_map[sdc.original_id] = uniq_source_data_criteria[identifier].id
+        else
+          uniq_source_data_criteria[identifier] = sdc
+        end
+      end
+      unique = uniq_source_data_criteria.values.reject { |dc| SourceDataCriteriaHelper.should_reject?(dc) }
+
+      # we need an empty data criteria in source that acts as the target for the specific occurrence
+      # the data criteria that we are duplicating will eventually get turned into a specific occurrence
+      occurrences = unique.select {|dc| occurrences_map[dc.id] && dc.definition != 'derived' }
+      occurrences.each do |occurrence|
+        # do not create a nonspecific SDC for variables
+        unless occurrence.variable
+          dc = SourceDataCriteriaHelper.as_source_data_criteria(occurrence.entry)
+          dc.id = "#{dc.id}_nonSpecific"
+          dc.instance_variable_set(:@source_data_criteria, dc.id)
+          unique << dc unless SourceDataCriteriaHelper.find_existing_source_data_criteria(unique, dc)
+        end
+      end
+
+      [unique, collapsed_source_data_criteria_map]
+    end
+  end
+end

data/lib/hqmf-parser/2.0/types.rb

@@ -3,35 +3,88 @@ module HQMF2
   # don't specify any restrictions on that value
   class AnyValue
     attr_reader :type
-    
-    def initialize(type='ANYNonNull')
-      @type = type 
+
+    def initialize(type = 'ANYNonNull')
+      @type = type
     end
-    
+
+    # Generates this classes hqmf-model equivalent
     def to_model
       HQMF::AnyValue.new(@type)
-    end    
+    end
   end
-  
+
   # Represents a bound within a HQMF pauseQuantity, has a value, a unit and an
   # inclusive/exclusive indicator
   class Value
     include HQMF2::Utilities
-    
+
     attr_reader :type, :unit, :value
-    
-    def initialize(entry, default_type='PQ', force_inclusive=false)
+
+    def initialize(entry, default_type = 'PQ', force_inclusive = false, _parent = nil)
       @entry = entry
       @type = attr_val('./@xsi:type') || default_type
       @unit = attr_val('./@unit')
       @value = attr_val('./@value')
       @force_inclusive = force_inclusive
+
+      # FIXME: Remove below when lengthOfStayQuantity unit is fixed
+      @unit = 'd' if @unit == 'days'
     end
-    
+
     def inclusive?
-      attr_val("../@#{@entry.name}Closed") == 'true' || @force_inclusive
+      # If the high and low value are at any time the same, then it must be an inclusive value.
+      equivalent = attr_val('../cda:low/@value') == attr_val('../cda:high/@value')
+
+      # If and inclusivity value is set for any specific value, then mark the value as inclusive.
+      # IDEA: This could be limited in future iterations by including the parent type (temporal reference, subset code,
+      # etc.)
+      inclusive_temporal_ref? || inclusive_length_of_stay? || inclusive_basic_values? || inclusive_subsets? ||
+        equivalent || @force_inclusive
     end
-    
+
+    # Check whether the temporal reference should be marked as inclusive
+    def inclusive_temporal_ref?
+      # FIXME: NINF is used instead of 0 sometimes...? (not in the IG)
+      # FIXME: Given nullFlavor, but IG uses it and nullValue everywhere...
+      less_than_equal_tr = attr_val('../@highClosed') == 'true' &&
+                           (attr_val('../cda:low/@value') == '0' || attr_val('../cda:low/@nullFlavor') == 'NINF')
+      greater_than_equal_tr = attr_val('../cda:high/@nullFlavor') == 'PINF' &&
+                              attr_val('../cda:low/@value')
+      # Both less and greater require lowClosed to be set to true
+      (less_than_equal_tr || greater_than_equal_tr) && attr_val('../@lowClosed') == 'true'
+    end
+
+    # Check whether the length of stay should be inclusive.
+    def inclusive_length_of_stay?
+      # lengthOfStay - EH111, EH108
+      less_than_equal_los = attr_val('../cda:low/@nullFlavor') == 'NINF' &&
+                            attr_val('../@highClosed') != 'false'
+
+      greater_than_equal_los = attr_val('../cda:high/@nullFlavor') == 'PINF' &&
+                               attr_val('../@lowClosed') != 'false'
+      # Both less and greater require that the type is PQ
+      (less_than_equal_los || greater_than_equal_los) && attr_val('@xsi:type') == 'PQ'
+    end
+
+    # Check is the basic values should be marked as inclusive, currently only checks for greater than case
+    def inclusive_basic_values?
+      # Basic values - EP65, EP9, and more
+      attr_val('../cda:high/@nullFlavor') == 'PINF' &&
+        attr_val('../cda:low/@value') &&
+        attr_val('../@lowClosed') != 'false' &&
+        attr_val('../@xsi:type') == 'IVL_PQ'
+    end
+
+    # Check if subset values should be marked as inclusive.  Currently only handles greater than
+    def inclusive_subsets?
+      # subset - EP128, EH108
+      attr_val('../cda:low/@value') != '0' &&
+        !attr_val('../cda:high/@value') &&
+        attr_val('../@lowClosed') != 'false' &&
+        !attr_val('../../../../../qdm:subsetCode/@code').nil?
+    end
+
     def derived?
       case attr_val('./@nullFlavor')
       when 'DER'
@@ -40,7 +93,7 @@ module HQMF2
         false
       end
     end
-    
+
     def expression
       if !derived?
         nil
@@ -48,53 +101,81 @@ module HQMF2
         attr_val('./cda:expression/@value')
       end
     end
-    
+
+    # Generates this classes hqmf-model equivalent
     def to_model
-      HQMF::Value.new(type,unit,value,inclusive?,derived?,expression)
+      HQMF::Value.new(type, unit, value, inclusive?, derived?, expression)
     end
   end
-  
+
   # Represents a HQMF physical quantity which can have low and high bounds
   class Range
     include HQMF2::Utilities
     attr_accessor :low, :high, :width
-    
-    def initialize(entry, type=nil)
+
+    def initialize(entry, type = nil)
       @type = type
       @entry = entry
-      if @entry
-        @low = optional_value("#{default_element_name}/cda:low", default_bounds_type)
-        @high = optional_value("#{default_element_name}/cda:high", default_bounds_type)
-        @width = optional_value("#{default_element_name}/cda:width", 'PQ')
-      end
+      return unless @entry
+      @low = optional_value("#{default_element_name}/cda:low", default_bounds_type)
+      @high = optional_value("#{default_element_name}/cda:high", default_bounds_type)
+      # Unset low bound to resolve verbose value bounds descriptions
+      @low = nil if (@high.try(:value) && @high.value.to_i > 0) && (@low.try(:value) && @low.value.try(:to_i) == 0)
+      @width = optional_value("#{default_element_name}/cda:width", 'PQ')
     end
-    
+
     def type
       @type || attr_val('./@xsi:type')
     end
-    
+
+    # Generates this classes hqmf-model equivalent
     def to_model
-      lm = low ? low.to_model : nil
-      hm = high ? high.to_model : nil
-      wm = width ? width.to_model : nil
+      lm = low.try(:to_model)
+      hm = high.try(:to_model)
+      wm = width.try(:to_model)
       model_type = type
       if @entry.at_xpath('./cda:uncertainRange', HQMF2::Document::NAMESPACES)
         model_type = 'IVL_PQ'
       end
-      HQMF::Range.new(model_type, lm, hm, wm)
+
+      if generate_any_value?(lm, hm)
+        # Generate AnyValue if the only elements in the range are AnyValues.
+        HQMF::AnyValue.new
+      elsif generate_value?(lm, hm)
+        # Generate a singel value if both low and high are the same
+        HQMF::Value.new(lm.type, nil, lm.value, lm.inclusive?, lm.derived?, lm.expression)
+      else
+        HQMF::Range.new(model_type, lm, hm, wm)
+      end
     end
-    
+
+    # Check if are only AnyValue elements for low and high
+    def generate_any_value?(lm, hm)
+      (lm.nil? || lm.is_a?(HQMF::AnyValue)) && (hm.nil? || hm.is_a?(HQMF::AnyValue))
+    end
+
+    # Check if the value for the range should actually produce a single value instead of a range (if low and high are
+    # the same)
+    def generate_value?(lm, hm)
+      !lm.nil? && lm.try(:value) == hm.try(:value) && lm.try(:unit).nil? && hm.try(:unit).nil?
+    end
+
     private
-    
+
+    # Either derives a value from a specific path or generates a new value (or returns nil if none found)
     def optional_value(xpath, type)
       value_def = @entry.at_xpath(xpath, HQMF2::Document::NAMESPACES)
-      if value_def
-        Value.new(value_def, type)
+      return unless value_def
+      if value_def['flavorId'] == 'ANY.NONNULL'
+        AnyValue.new
       else
-        nil
+        created_value = Value.new(value_def, type)
+        # Return nil if no value was parsed
+        created_value if created_value.try(:value)
       end
     end
 
+    # Defines how the time based element should be described
     def default_element_name
       case type
       when 'IVL_PQ'
@@ -105,7 +186,8 @@ module HQMF2
         'cda:uncertainRange'
       end
     end
-    
+
+    # Sets up the default bound type as either time based or a physical quantity
     def default_bounds_type
       case type
       when 'IVL_TS'
@@ -115,38 +197,38 @@ module HQMF2
       end
     end
   end
-  
-  # Represents a HQMF effective time which is a specialization of a interval
+
+  # Represents an HQMF effective time which is a specialization of an interval
   class EffectiveTime < Range
     def initialize(entry)
       super
     end
-    
+
     def type
       'IVL_TS'
     end
   end
-  
+
   # Represents a HQMF CD value which has a code and codeSystem
   class Coded
     include HQMF2::Utilities
-    
+
     def initialize(entry)
       @entry = entry
     end
-    
+
     def type
       attr_val('./@xsi:type') || 'CD'
     end
-    
+
     def system
       attr_val('./@codeSystem')
     end
-    
+
     def code
       attr_val('./@code')
     end
-    
+
     def code_list_id
       attr_val('./@valueSet')
     end
@@ -166,103 +248,201 @@ module HQMF2
     def unit
       nil
     end
-    
+
+    # Generates this classes hqmf-model equivalent
     def to_model
       HQMF::Coded.new(type, system, code, code_list_id, title)
     end
-    
   end
-  
+  # Represents a subset of a specific group (the first in the group, the sum of the group, etc.)
   class SubsetOperator
     include HQMF2::Utilities
 
     attr_reader :type, :value
+    ORDER_SUBSETS = %w(FIRST SECOND THIRD FOURTH FIFTH)
+    LAST_SUBSETS = %w(LAST RECENT)
+    TIME_SUBSETS = %w(DATEDIFF TIMEDIFF)
+    QDM_TYPE_MAP = { 'QDM_LAST:' => 'RECENT', 'QDM_SUM:SUM' => 'COUNT' }
 
     def initialize(entry)
       @entry = entry
-      @type = attr_val('./cda:subsetCode/@code')
+
+      sequence_number = attr_val('./cda:sequenceNumber/@value')
+      qdm_subset_code = attr_val('./qdm:subsetCode/@code')
+      subset_code = attr_val('./cda:subsetCode/@code')
+      if sequence_number
+        @type = ORDER_SUBSETS[sequence_number.to_i - 1]
+      else
+        @type = translate_type(subset_code, qdm_subset_code)
+      end
+
+      value_def = handle_value_definition
+      @value = HQMF2::Range.new(value_def, 'IVL_PQ') if value_def && !@value
+    end
+
+    # Return the value definition (what to calculate it on) associated with this subset.
+    # Other values, such as type and value, may be modified depending on this value.
+    def handle_value_definition
       value_def = @entry.at_xpath('./*/cda:repeatNumber', HQMF2::Document::NAMESPACES)
-      if !value_def
+      unless value_def
+        # TODO: HQMF needs better differentiation between SUM & COUNT...
+        # currently using presence of repeatNumber...
+        @type = 'SUM' if @type == 'COUNT'
         value_def = @entry.at_xpath('./*/cda:value', HQMF2::Document::NAMESPACES)
       end
+
+      # TODO: Resolve extracting values embedded in criteria within outboundRel's
+      if @type == 'SUM'
+        value_def = @entry.at_xpath('./*/*/*/cda:value', HQMF2::Document::NAMESPACES)
+      end
+
       if value_def
         value_type = value_def.at_xpath('./@xsi:type', HQMF2::Document::NAMESPACES)
-        if String.try_convert(value_type) ==  "ANY"
-          @value = HQMF2::AnyValue.new()
-        end
+        @value = HQMF2::AnyValue.new if String.try_convert(value_type) == 'ANY'
       end
 
-      if value_def && !@value
-        @value = HQMF2::Range.new(value_def, 'IVL_PQ')
+      value_def
+    end
+
+    # Take a qdm type code to map it to a subset operator, or failing at finding that, return the given subset code.
+    def translate_type(subset_code, qdm_subset_code)
+      combined = "#{qdm_subset_code}:#{subset_code}"
+      if QDM_TYPE_MAP[combined]
+        QDM_TYPE_MAP[combined]
+      else
+        subset_code
       end
     end
 
+    # Generates this classes hqmf-model equivalent
     def to_model
       vm = value ? value.to_model : nil
       HQMF::SubsetOperator.new(type, vm)
     end
   end
-  
+
+  # Represents a time bounded reference.  Wraps the "Range" class
   class TemporalReference
     include HQMF2::Utilities
-    
+
     attr_reader :type, :reference, :range
 
+    # Use updated mappings to HDS temporal reference types (as used in SimpleXML Parser)
+    # https://github.com/projecttacoma/simplexml_parser/blob/fa0f589d98059b88d77dc3cb465b62184df31671/lib/model/types.rb#L167
+    UPDATED_TYPES = {
+      'EAOCW' => 'EACW',
+      'EAEORECW' => 'EACW',
+      'EAOCWSO' => 'EACWS',
+      'EASORECWS' => 'EACWS',
+      'EBOCW' => 'EBCW',
+      'EBEORECW' => 'EBCW',
+      'EBOCWSO' => 'EBCWS',
+      'EBSORECWS' => 'EBCWS',
+      'ECWSO' => 'ECWS',
+      'SAOCWEO' => 'SACWE',
+      'SAEORSCWE' => 'SACWE',
+      'SAOCW' => 'SACW',
+      'SASORSCW' => 'SACW',
+      'SBOCWEO' => 'SBCWE',
+      'SBEORSCWE' => 'SBCWE',
+      'SBOCW' => 'SBCW',
+      'SBSORSCW' => 'SBCW',
+      'SCWEO' => 'SCWE',
+      'OVERLAPS' => 'OVERLAP'
+    }
+
     def initialize(entry)
       @entry = entry
-      @type = attr_val('./@typeCode')
+      @type = UPDATED_TYPES[attr_val('./@typeCode')] || attr_val('./@typeCode')
       @reference = Reference.new(@entry.at_xpath('./*/cda:id', HQMF2::Document::NAMESPACES))
-      range_def = @entry.at_xpath('./cda:pauseQuantity', HQMF2::Document::NAMESPACES)
-      if range_def
-        @range = HQMF2::Range.new(range_def, 'PQ')
-      end
+      range_def = @entry.at_xpath('./qdm:temporalInformation/qdm:delta', HQMF2::Document::NAMESPACES)
+      @range = HQMF2::Range.new(range_def, 'IVL_PQ') if range_def
     end
-    
+
+    # Generates this classes hqmf-model equivalent
     def to_model
       rm = range ? range.to_model : nil
       HQMF::TemporalReference.new(type, reference.to_model, rm)
-    end  
+    end
   end
 
-# Represents a HQMF reference to a data criteria that has a given type
+  # Represents a HQMF reference to a data criteria that has a given type
   class TypedReference
     include HQMF2::Utilities
     attr_accessor :id, :type, :mood
 
     # Create a new HQMF::Reference
     # @param [String] id
-    def initialize(entry)
+    def initialize(entry, type = nil, verbose = false)
       @entry = entry
       @type = type || attr_val('./@classCode')
       @mood = attr_val('./@moodCode')
       @entry = entry.elements.first unless entry.at_xpath('./@extension')
+      @verbose = verbose
     end
 
+    # Generate the reference for the typed reference to use
     def reference
-      attr_val('./@extension')
+      value = "#{attr_val('./@extension')}_#{attr_val('./@root')}"
+      strip_tokens(value)
     end
 
+    # Generates this classes hqmf-model equivalent
     def to_model
-      HQMF::TypedReference.new(reference,@type,@mood)
+      HQMF::TypedReference.new(reference, @type, @mood)
     end
-
   end
 
   # Represents a HQMF reference from a precondition to a data criteria
   class Reference
     include HQMF2::Utilities
-    
+
     def initialize(entry)
       @entry = entry
     end
-    
+
+    # Generates the id to use for a reference
     def id
-      attr_val('./@extension')
+      if @entry.is_a? String
+        @entry
+      else
+        id = strip_tokens("#{attr_val('./@extension')}_#{attr_val('./@root')}")
+        # Handle MeasurePeriod references for calculation code
+        id = 'MeasurePeriod' if id.try(:start_with?, 'measureperiod')
+        id
+      end
     end
-    
+
+    # Generates this classes hqmf-model equivalent
     def to_model
       HQMF::Reference.new(id)
     end
   end
-  
+
+  # Creates a Data Criteria given a map of options, and is used when full
+  #  criteria parsing is not necessary.
+  class DataCriteriaWrapper
+    attr_accessor :status, :value, :effective_time
+    attr_accessor :temporal_references, :subset_operators, :children_criteria
+    attr_accessor :derivation_operator, :negation, :negation_code_list_id, :description
+    attr_accessor :field_values, :source_data_criteria, :specific_occurrence_const
+    attr_accessor :specific_occurrence, :comments
+    attr_accessor :id, :title, :definition, :variable, :code_list_id, :value, :inline_code_list
+
+    def initialize(opts = {})
+      opts.each { |k, v| instance_variable_set("@#{k}", v) }
+    end
+
+    # Generates this classes hqmf-model equivalent
+    def to_model
+      mv = @value ? @value.to_model : nil
+      met = @effective_time ? @effective_time.to_model : nil
+      mtr = @temporal_references
+      mso = @subset_operators
+      HQMF::DataCriteria.new(@id, @title, nil, @description, @code_list_id, @children_criteria,
+                             @derivation_operator, @definition, @status, mv, field_values, met, @inline_code_list,
+                             @negation, @negation_code_list_id, mtr, mso, @specific_occurrence,
+                             @specific_occurrence_const, @source_data_criteria, @comments, @variable)
+    end
+  end
 end