cqm-parsers 0.1.0

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

@@ -0,0 +1,134 @@
+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
+    attr_accessor :type
+    # Create a new population criteria from the supplied HQMF entry
+    # @param [Nokogiri::XML::Element] the HQMF entry
+    def initialize(entry, doc, id_generator)
+      @id_generator = id_generator
+      @doc = doc
+      @entry = entry
+      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))] if dc
+      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')
+      @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 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
+      # 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
+
+    # 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, HQMF::PopulationCriteria::STRAT
+        HQMF::Precondition::ALL_TRUE
+      when HQMF::PopulationCriteria::DENEXCEP, HQMF::PopulationCriteria::DENEX, HQMF::PopulationCriteria::MSRPOPLEX,
+           HQMF::PopulationCriteria::NUMEX
+        HQMF::Precondition::AT_LEAST_ONE_TRUE
+      else
+        fail "Unknown population type [#{@type}]"
+      end
+    end
+
+    # Generates this classes hqmf-model equivalent
+    def 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

@@ -0,0 +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, :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
+      preconditions.compact!
+      handle_aggregation(id_generator, reference, preconditions, aggregation)
+    end
+
+    # "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
+        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(&: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

@@ -0,0 +1,448 @@
+module HQMF2
+  # Used to represent 'any value' in criteria that require a value be present but
+  # don't specify any restrictions on that value
+  class AnyValue
+    attr_reader :type
+
+    def initialize(type = 'ANYNonNull')
+      @type = type
+    end
+
+    # Generates this classes hqmf-model equivalent
+    def to_model
+      HQMF::AnyValue.new(@type)
+    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, _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?
+      # 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'
+        true
+      else
+        false
+      end
+    end
+
+    def expression
+      if !derived?
+        nil
+      else
+        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)
+    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)
+      @type = type
+      @entry = entry
+      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.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
+
+      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)
+      return unless value_def
+      if value_def['flavorId'] == 'ANY.NONNULL'
+        AnyValue.new
+      else
+        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'
+        '.'
+      when 'IVL_TS'
+        'cda:phase'
+      else
+        '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'
+        'TS'
+      else
+        'PQ'
+      end
+    end
+  end
+
+  # 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
+
+    def title
+      attr_val('./*/@value')
+    end
+
+    def value
+      code
+    end
+
+    def derived?
+      false
+    end
+
+    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
+
+      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)
+      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)
+        @value = HQMF2::AnyValue.new if String.try_convert(value_type) == 'ANY'
+      end
+
+      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 = UPDATED_TYPES[attr_val('./@typeCode')] || attr_val('./@typeCode')
+      @reference = Reference.new(@entry.at_xpath('./*/cda:id', HQMF2::Document::NAMESPACES))
+      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
+
+  # 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, 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
+      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)
+    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
+      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