openehr 1.3.0 → 2.0.0

data/lib/openehr/assumed_library_types.rb

@@ -71,6 +71,35 @@ module OpenEHR
           (@lower_included == value.lower_included?) &&
             (@upper_included == value.upper_included?)
       end
+
+      # True if every value this interval has is also had by other (a
+      # standard subset test, e.g. for conformance checks: does a
+      # constraint's occurrences/existence/cardinality interval fit
+      # within its parent's).
+      def subset_of?(other)
+        return false if other.nil?
+
+        lower_ok = if lower_unbounded?
+                     other.lower_unbounded?
+                   elsif other.lower_unbounded? || lower > other.lower
+                     true
+                   elsif lower == other.lower
+                     !lower_included? || other.lower_included?
+                   else
+                     false
+                   end
+        upper_ok = if upper_unbounded?
+                     other.upper_unbounded?
+                   elsif other.upper_unbounded? || upper < other.upper
+                     true
+                   elsif upper == other.upper
+                     !upper_included? || other.upper_included?
+                   else
+                     false
+                   end
+        lower_ok && upper_ok
+      end
+
       private
 
       def check_lower_upper(lower, upper)
@@ -441,6 +470,8 @@ module OpenEHR
               return false
             end
           end
+          # A timezone is optional in ISO 8601; its absence does not make an
+          # otherwise-valid time invalid.
           unless tz.nil?
             timezone = Timezone.new(tz)
             if timezone.hour < 0 or timezone.hour >= HOURS_IN_DAY
@@ -449,10 +480,8 @@ module OpenEHR
             if timezone.minute < 0 or timezone.minute >= MINUTES_IN_HOUR
               return false
             end
-            return true
-          else
-            return false
           end
+          return true
         end
       end
     end # end of ISO8601_TIME
@@ -589,6 +618,19 @@ module OpenEHR
       include TimeDefinitions
       attr_reader :years, :months, :weeks, :days
       attr_reader :hours, :minutes, :seconds, :fractional_second
+      # RM 1.1.0 (SPECRM-96): a leading '-' before 'P' negates the whole
+      # duration (e.g. "-P10D", 10 days before an unstated origin point).
+      # Components stay non-negative magnitudes - the sign applies to
+      # the duration as a whole, not each field - so it's tracked here.
+      attr_reader :negative
+
+      def negative=(negative)
+        @negative = negative ? true : false
+      end
+
+      def negative?
+        @negative == true
+      end
 
       def years=(years)
         unless years.nil? || years >= 0
@@ -647,7 +689,7 @@ module OpenEHR
       end
 
       def as_string
-        str = 'P'
+        str = negative? ? '-P' : 'P'
         unless @years.nil?
           str += @years.to_s + 'Y'
         end
@@ -681,27 +723,36 @@ module OpenEHR
           nilthenzero(@months)*TimeDefinitions::DAYS_IN_MONTH +
           nilthenzero(@weeks)*TimeDefinitions::DAYS_IN_WEEK + 
           nilthenzero(@days)
-        seconds_with_fractional = (((days*TimeDefinitions::HOURS_IN_DAY + nilthenzero(@hours))*TimeDefinitions::MINUTES_IN_HOUR)+nilthenzero(@minutes))*TimeDefinitions::SECONDS_IN_MINUTE + 
+        seconds_with_fractional = (((days*TimeDefinitions::HOURS_IN_DAY + nilthenzero(@hours))*TimeDefinitions::MINUTES_IN_HOUR)+nilthenzero(@minutes))*TimeDefinitions::SECONDS_IN_MINUTE +
           nilthenzero(@seconds) +
           @fractional_second.to_f
-        return seconds_with_fractional
+        return negative? ? -seconds_with_fractional : seconds_with_fractional
       end
     end
 
     class ISO8601Duration
       include ISO8601DurationModule, Comparable
       def initialize(str)
-        /^P((\d+)[Yy])?((\d+)[Mm])?((\d+)[Ww])?((\d)[dD])?(T((\d+)[Hh])?((\d+)[Mm])?((\d+)(\.\d+)?[Ss])?)?$/ =~ str
-        self.years = $2.to_i
-        self.months = $4.to_i
-        self.weeks = $6.to_i
-        self.days = $8.to_i
-        self.hours = $11.to_i
-        self.minutes = $13.to_i
-        self.seconds = $15.to_i
-        unless $16.nil?
-          self.fractional_second = $16.to_f
-        end
+        # A leading '-' negates the whole duration (RM 1.1.0, SPECRM-96);
+        # stripped before the main match so the existing capture group
+        # numbering below doesn't need to shift.
+        self.negative = str.start_with?('-')
+        duration_str = negative? ? str[1..-1] : str
+        md = /^P((\d+)[Yy])?((\d+)[Mm])?((\d+)[Ww])?((\d+)[dD])?(T((\d+)[Hh])?((\d+)[Mm])?((\d+)(\.\d+)?[Ss])?)?$/.match(duration_str)
+        if md.nil?
+          raise ArgumentError, 'invalid ISO8601 duration format'
+        end
+        # Absent components stay nil rather than being coerced to 0, so
+        # as_string can round-trip a partially-specified duration and
+        # "unset" is distinguishable from "explicitly zero".
+        self.years = md[2] && md[2].to_i
+        self.months = md[4] && md[4].to_i
+        self.weeks = md[6] && md[6].to_i
+        self.days = md[8] && md[8].to_i
+        self.hours = md[11] && md[11].to_i
+        self.minutes = md[13] && md[13].to_i
+        self.seconds = md[15] && md[15].to_i
+        self.fractional_second = md[16] && md[16].to_f
       end
 
       def <=>(other)

data/lib/openehr/parser/adl_grammar.tt

@@ -15,7 +15,7 @@ module OpenEHR
         lang:(arch_language)?
         desc:(arch_description)?
         arch_definition
-        arch_invariant?
+        inv:(arch_invariant)?
         arch_ontology {
           def archetype_id
             arch_identification.archetype_id
@@ -52,6 +52,14 @@ module OpenEHR
           def ontology
             arch_ontology.value
           end
+
+          def parent_archetype_id
+            spec.archetype_id unless spec.empty?
+          end
+
+          def invariants
+            inv.value unless inv.empty?
+          end
         }
       end
 
@@ -116,9 +124,9 @@ module OpenEHR
             { :uid => uid.value }
           end
         }
-      / SYM_IS_CONTROLED space {
+      / SYM_IS_CONTROLLED space {
           def value
-	    { :is_controled? => true } # If elements[0]
+	    { :is_controlled? => true } # If elements[0]
           end
         }
       end
@@ -194,7 +202,11 @@ module OpenEHR
       end
 
       rule arch_invariant
-        SYM_INVARIANT V_ASSERTION_TEXT space
+        SYM_INVARIANT text:V_ASSERTION_TEXT space {
+          def value
+            text.value
+          end
+        }
       end
 
       rule arch_ontology
@@ -327,7 +339,7 @@ module OpenEHR
       rule c_complex_object_body
         c_any '' {
           def value(node)
-            Hash[:attributes => [c_any.value(node)]]
+            Hash[:attributes => nil]
           end
         }
       / c_attributes '' {
@@ -386,10 +398,10 @@ module OpenEHR
         }
       / V_C_DOMAIN_TYPE '' {
           def value(node = nil)
-            p elemetns
+            raise OpenEHR::Parser::ParseError,
+              "generic C_DOMAIN_TYPE constraints (e.g. C_DV_STATE) are not yet supported by the ADL parser: #{text_value}"
           end
         }
-#     / ERR_V_C_DOMAIN_TYPE
       end
 
       rule archetype_internal_ref
@@ -1460,7 +1472,7 @@ module OpenEHR
           def value
             if (id && !id.empty?)
               OpenEHR::AM::Archetype::Assertion::Assertion.new(
-                :tag => id.value, :expression => boolean_expression.value,
+                :tag => id.elements[0].value, :expression => boolean_expression.value,
                 :string_expression => id.text_value + boolean_expression.text_value)
             else
               OpenEHR::AM::Archetype::Assertion::Assertion.new(
@@ -1726,7 +1738,7 @@ module OpenEHR
         }
       / integer_value '' {
           def value
-            OpenEHR::AM::Archetype::ConstraintModel::ExprLeaf.new(
+            OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
               :type => 'Integer',
               :item => integer_value.value,
               :reference_type => 'CONSTANT')
@@ -1734,7 +1746,7 @@ module OpenEHR
         }
       / real_value '' {
           def value
-            OpenEHR::AM::Archetype::ConstraintModel::ExprLeaf.new(
+            OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
               :type => 'Real',
               :item => real_value.value,
               :reference_type => 'CONSTANT')
@@ -1742,7 +1754,7 @@ module OpenEHR
         }
       / absolute_path space {
           def value
-            OpenEHR::AM::Archetype::ConstraintModel::ExprLeaf.new(
+            OpenEHR::AM::Archetype::Assertion::ExprLeaf.new(
               :type => 'String',
               :item => absolute_path.value,
               :reference_type => 'CONSTANT')
@@ -2168,9 +2180,9 @@ module OpenEHR
             type_identifier.value
           end
         }
-      / V_ATTRIBUTE_IDENTIFIER '' {
+      / id:V_ATTRIBUTE_IDENTIFIER '' {
           def value
-            V_ATTRIBUTE_IDENTIFIER.value
+            id.value
           end
         }
       end
@@ -3004,6 +3016,10 @@ module OpenEHR
         '=' white_space
       end
 
+      rule SYM_NE
+        '!=' white_space
+      end
+
       rule SYM_GE
         ('=>' / '>=') white_space
       end

data/lib/openehr/parser/adl_parser.rb

@@ -13,8 +13,10 @@ module OpenEHR
         super
       end
       
-      def parse
-        archetype
+      def parse(validate: false)
+        archetype.tap do |a|
+          ArchetypeValidator.new(a).validate! if validate
+        end
       end
 
       private
@@ -67,6 +69,16 @@ module OpenEHR
         parsed_data.concept
       end
 
+      def parent_archetype_id
+        if parsed_data.parent_archetype_id
+          OpenEHR::RM::Support::Identification::ArchetypeID.new(:value => parsed_data.parent_archetype_id)
+        end
+      end
+
+      def invariants
+        parsed_data.invariants
+      end
+
       def description
         parsed_data.description
       end
@@ -82,13 +94,15 @@ module OpenEHR
       def archetype
         OpenEHR::AM::Archetype::Archetype.new(:archetype_id => archetype_id,
                                   :adl_version => adl_version,
-                                  :uid => uid,            
+                                  :uid => uid,
                                   :concept => concept,
                                   :original_language => original_language,
                                   :translations => translations,
                                   :description => description,
                                   :definition => definition,
-                                  :ontology => ontology)
+                                  :ontology => ontology,
+                                  :parent_archetype_id => parent_archetype_id,
+                                  :invariants => invariants)
       end
     end
   end # of Parser

data/lib/openehr/parser/archetype_validator.rb

@@ -0,0 +1,126 @@
+require_relative 'exception'
+
+module OpenEHR
+  module Parser
+    # Post-parse semantic validator, checking a parsed archetype
+    # against the VARID..VDFPT rules (Beale07, p.100). VARID/VARDF/
+    # VARON/VDFAI are already enforced structurally by the RM/AM
+    # object model itself (their setters raise on construction), so
+    # they can never actually fail here - they're still checked
+    # explicitly, both for rule-traceability and so a validator run
+    # against a duck-typed object (not necessarily a real
+    # OpenEHR::AM::Archetype::Archetype) stays honest.
+    class ArchetypeValidator
+      Validation = Exception::Validation
+
+      def initialize(archetype)
+        @archetype = archetype
+      end
+
+      def errors
+        RULES.filter_map { |rule| send(rule) }
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      def validate!
+        error = errors.first
+        raise error if error
+      end
+
+      # Checks +rm_root+ against the archetype's definition, returning
+      # a path-annotated OpenEHR::Parser::Exception::Validation::
+      # InstanceNonConformant for the first violation found (path
+      # resolved via rm_root.path_of_item, the PATHABLE navigation
+      # method), or [] when rm_root fully conforms.
+      def validate_instance(rm_root)
+        return [] if @archetype.definition.valid_value?(rm_root)
+
+        _node, value = @archetype.definition.find_violation(rm_root)
+        message = "value does not conform to #{@archetype.archetype_id.value}"
+        [Validation::InstanceNonConformant.new(message, resolve_path(rm_root, value))]
+      end
+
+      private
+
+      def resolve_path(rm_root, value)
+        return nil unless rm_root.respond_to?(:path_of_item)
+
+        rm_root.path_of_item(value)
+      end
+
+      def varid
+        Validation::VARID.new(Validation::VARID::MESSAGE) if @archetype.archetype_id.nil?
+      end
+
+      def vardf
+        Validation::VARDF.new(Validation::VARDF::MESSAGE) if @archetype.definition.nil?
+      end
+
+      def varon
+        Validation::VARON.new(Validation::VARON::MESSAGE) if @archetype.ontology.nil?
+      end
+
+      def varcn
+        return if @archetype.concept.nil?
+        return if @archetype.ontology.term_codes.include?(@archetype.concept)
+
+        Validation::VARCN.new(Validation::VARCN::MESSAGE)
+      end
+
+      def vardt
+        definition_type = @archetype.definition.rm_type_name.to_s.upcase
+        id_type = @archetype.archetype_id.rm_entity.to_s.upcase
+        return if definition_type == id_type
+
+        Validation::VARDT.new(Validation::VARDT::MESSAGE)
+      end
+
+      def vatdf
+        Validation::VATDF.new(Validation::VATDF::MESSAGE) unless @archetype.node_ids_valid?
+      end
+
+      def vacdf
+        Validation::VACDF.new(Validation::VACDF::MESSAGE) unless @archetype.constraint_references_valid?
+      end
+
+      # In practice this can never actually fail through this gem's own
+      # object model: CArchetypeRoot#archetype_id= already rejects
+      # anything but a well-typed ArchetypeID at construction time.
+      # Still checked genuinely (rather than a hardcoded pass) in case
+      # +archetype+ is a duck-typed object built some other way.
+      def vdfai
+        return if archetype_roots(@archetype.definition).all? do |id|
+          id.is_a?(OpenEHR::RM::Support::Identification::ArchetypeID)
+        end
+
+        Validation::VDFAI.new(Validation::VDFAI::MESSAGE)
+      end
+
+      def archetype_roots(node, found = [])
+        return found if node.nil?
+
+        found << node.archetype_id if node.is_a?(OpenEHR::AM::Archetype::ConstraintModel::CArchetypeRoot)
+        if node.respond_to?(:attributes) && node.attributes
+          node.attributes.each { |attribute| archetype_roots(attribute, found) }
+        end
+        if node.respond_to?(:children) && node.children
+          node.children.each { |child| archetype_roots(child, found) }
+        end
+        found
+      end
+
+      def vdfpt
+        return if @archetype.internal_references_valid? &&
+                  @archetype.physical_paths.all? { |path| OpenEHR::Path.valid?(path) }
+
+        Validation::VDFPT.new(Validation::VDFPT::MESSAGE)
+      end
+
+      RULES = %i[varid vardf varon varcn vardt vatdf vacdf vdfai vdfpt].freeze
+      private_constant :RULES
+    end
+  end
+end

data/lib/openehr/parser/exception.rb

@@ -60,6 +60,19 @@ module OpenEHR
         class VDFPT < Base
           MESSAGE = "Any path mentioned in the definition section must be valid syntactically, and a valid path with respect to the hierarchical structure of the definition section."
         end
+
+        # Raised by ArchetypeValidator#validate_instance for an RM
+        # instance that does not conform to an archetype's definition;
+        # not one of the VARID..VDFPT archetype-structure rules, since
+        # this checks an RM instance against the archetype instead.
+        class InstanceNonConformant < Base
+          attr_reader :path
+
+          def initialize(message, path = nil)
+            super(message)
+            @path = path
+          end
+        end
       end
 
     end

data/lib/openehr/parser/opt_parser.rb

@@ -40,7 +40,7 @@ module OpenEHR
         @opt = Nokogiri::XML::Document.parse(File.open(@filename))
         @opt.remove_namespaces!
         
-        uid = OpenEHR::RM::Support::Identification::UIDBasedID.new(value: text_on_path(@opt, UID_PATH))
+        uid = build_uid
         defs = definition
         
         # Create operational template with archetype-compatible parameters
@@ -52,7 +52,7 @@ module OpenEHR
           template_id: template_id,
           archetype_id: template_id,  # Use template_id as archetype_id for compatibility
           definition: defs,
-          ontology: create_template_ontology,
+          ontology: (@component_terminologies || {})[defs.archetype_id.value] || create_template_ontology,
           component_terminologies: @component_terminologies || {},
           terminology_extracts: @component_terminologies || {},
           adl_version: "1.4"
@@ -61,8 +61,20 @@ module OpenEHR
 
       private
 
+      # template_id is mandatory for an operational template (enforced by
+      # OperationalTemplate itself); a missing/blank <template_id> element
+      # must therefore resolve to nil rather than an invalid TemplateID.
       def template_id
-        @template_id ||= OpenEHR::RM::Support::Identification::TemplateID.new(value: text_on_path(@opt, TEMPLATE_ID_PATH))
+        return @template_id if @template_id
+        value = text_on_path(@opt, TEMPLATE_ID_PATH)
+        @template_id = value.nil? || value.empty? ? nil : OpenEHR::RM::Support::Identification::TemplateID.new(value: value)
+      end
+
+      # uid is optional on an operational template; a missing/blank <uid>
+      # element must resolve to nil rather than an invalid UIDBasedID.
+      def build_uid
+        value = text_on_path(@opt, UID_PATH)
+        value.nil? || value.empty? ? nil : OpenEHR::RM::Support::Identification::UIDBasedID.new(value: value)
       end
 
       def concept
@@ -260,7 +272,12 @@ module OpenEHR
         upper_included = upper_included_node ? to_bool(upper_included_node.text) : (upper.nil? ? nil : true)
         lower_unbounded = lower_unbounded_node ? to_bool(lower_unbounded_node.text) : false
         upper_unbounded = upper_unbounded_node ? to_bool(upper_unbounded_node.text) : false
-        
+
+        # An occurrences element with none of its children present carries no
+        # constraint at all; Interval requires at least one bound, so treat
+        # this as "no occurrences data" rather than raising.
+        return nil if lower.nil? && upper.nil? && !lower_unbounded && !upper_unbounded
+
         # Handle unbounded intervals properly
         if upper_unbounded || upper.nil?
           upper = nil
@@ -282,11 +299,14 @@ module OpenEHR
 
       def cardinality(xml)
         return nil if xml.nil?
-        
+
         order_node = xml.at('is_ordered')
         unique_node = xml.at('is_unique')
         interval_node = xml.at('interval')
-        
+
+        # No cardinality sub-elements at all means no cardinality data.
+        return nil if order_node.nil? && unique_node.nil? && interval_node.nil?
+
         order = order_node ? to_bool(order_node.text) : false
         unique = unique_node ? to_bool(unique_node.text) : false
         interval = interval_node ? occurrences(interval_node) : nil
@@ -298,6 +318,21 @@ module OpenEHR
         )
       end        
 
+      def archetype_internal_ref(attr_xml, node)
+        rm_type_name = attr_xml.at('rm_type_name').text
+        target_path = attr_xml.at('target_path').text
+        occurrences = occurrences(attr_xml.at('occurrences'))
+        OpenEHR::AM::Archetype::ConstraintModel::ArchetypeInternalRef.new(rm_type_name: rm_type_name, occurrences: occurrences, target_path: target_path)
+      end
+
+      # No .opt fixture in this gem's corpus uses a C_DV_STATE (state
+      # machine) constraint, so its actual OPT XML shape is unverified;
+      # raising a clear, documented error here is safer than guessing
+      # at element names and risking a silently wrong StateMachine.
+      def c_dv_state(_attr_xml, _node)
+        raise NotImplementedError, 'OPTParser does not yet support C_DV_STATE (state machine) constraints'
+      end
+
       def constraint_ref(attr_xml, node)
         rm_type_name = attr_xml.at('rm_type_name').text
         reference = attr_xml.at('reference').text
@@ -354,9 +389,7 @@ module OpenEHR
       def c_dv_quantity(attr_xml, node)
         rm_type_name = attr_xml.at('rm_type_name').text
         occurrences = occurrences(attr_xml.at('occurrences'))
-        property_terminology_id = OpenEHR::RM::Support::Identification::TerminologyID.new(value: attr_xml.at('property/terminology_id/value').text)
-        property_code_string = attr_xml.at('property/code_string').text
-        property = OpenEHR::RM::DataTypes::Text::CodePhrase.new(terminology_id: property_terminology_id, code_string: property_code_string)
+        property = property_code_phrase(attr_xml.at('property'))
         list = attr_xml.xpath('.//list').map do |element|
           units = element.at('units').text if element.at('units')
           magnitude = occurrences(element.at('magnitude')) if element.at('magnitude')
@@ -366,6 +399,59 @@ module OpenEHR
         OpenEHR::AM::OpenEHRProfile::DataTypes::Quantity::CDvQuantity.new(rm_type_name: rm_type_name, occurrences: occurrences, list: list, property: property)
       end
 
+      # The <property> element is optional in real templates; return nil rather
+      # than dereferencing missing terminology/code nodes.
+      def property_code_phrase(property_xml)
+        return nil if property_xml.nil?
+        terminology_node = property_xml.at('terminology_id/value')
+        code_node = property_xml.at('code_string')
+        return nil if terminology_node.nil? || code_node.nil?
+        terminology_id = OpenEHR::RM::Support::Identification::TerminologyID.new(value: terminology_node.text)
+        OpenEHR::RM::DataTypes::Text::CodePhrase.new(terminology_id: terminology_id, code_string: code_node.text)
+      end
+
+      def c_dv_ordinal(attr_xml, node)
+        rm_type_name = attr_xml.at('rm_type_name').text
+        occurrences = occurrences(attr_xml.at('occurrences'))
+        list = attr_xml.xpath('list').map { |element| dv_ordinal_item(element) }.compact
+        OpenEHR::AM::OpenEHRProfile::DataTypes::Quantity::CDvOrdinal.new(rm_type_name: rm_type_name, occurrences: occurrences, list: list)
+      end
+
+      # DV_ORDINAL.symbol is spec'd as DV_CODED_TEXT; the OPT XML only
+      # carries a defining_code (terminology_id + code_string), so the
+      # DvCodedText's own value is set to that same code_string (there
+      # is no separate display text in this element).
+      def dv_ordinal_item(element)
+        value_node = element.at('value')
+        return nil unless value_node && !value_node.text.empty?
+
+        code_phrase = property_code_phrase(element.at('symbol/defining_code'))
+        return nil if code_phrase.nil?
+
+        symbol = OpenEHR::RM::DataTypes::Text::DvCodedText.new(value: code_phrase.code_string, defining_code: code_phrase)
+        OpenEHR::RM::DataTypes::Quantity::DvOrdinal.new(value: value_node.text.to_i, symbol: symbol)
+      end
+
+      def c_dv_scale(attr_xml, node)
+        rm_type_name = attr_xml.at('rm_type_name').text
+        occurrences = occurrences(attr_xml.at('occurrences'))
+        list = attr_xml.xpath('list').map { |element| dv_scale_item(element) }.compact
+        OpenEHR::AM::OpenEHRProfile::DataTypes::Quantity::CDvScale.new(rm_type_name: rm_type_name, occurrences: occurrences, list: list)
+      end
+
+      # Same XML shape as C_DV_ORDINAL's list items, but DV_SCALE.value
+      # is Real rather than Integer.
+      def dv_scale_item(element)
+        value_node = element.at('value')
+        return nil unless value_node && !value_node.text.empty?
+
+        code_phrase = property_code_phrase(element.at('symbol/defining_code'))
+        return nil if code_phrase.nil?
+
+        symbol = OpenEHR::RM::DataTypes::Text::DvCodedText.new(value: code_phrase.code_string, defining_code: code_phrase)
+        OpenEHR::RM::DataTypes::Quantity::DvScale.new(value: value_node.text.to_f, symbol: symbol)
+      end
+
       def c_date(xml)
         pattern = xml.at('pattern')
         range = xml.at('range')
@@ -403,6 +489,73 @@ module OpenEHR
         end
       end
 
+      def c_real(xml)
+        range = xml.at('range')
+        list = xml.xpath('list')
+        if range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new(range: occurrences(range))
+        elsif !list.empty?
+          list_values = list.map { |item| item.text.to_f }
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new(list: list_values)
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CReal.new
+        end
+      end
+
+      def c_duration(xml)
+        pattern = xml.at('pattern')
+        range_xml = xml.at('range')
+        list = xml.xpath('list')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(pattern: pattern.text)
+        elsif range_xml
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(range: duration_range(range_xml))
+        elsif !list.empty?
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new(list: list.map(&:text))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CDuration.new
+        end
+      end
+
+      # A C_DURATION range's bounds are ISO8601 duration strings (e.g.
+      # PT24H), not plain numbers, so occurrences() (built for numeric
+      # Interval bounds) doesn't apply here; wrap each bound as a
+      # DV_DURATION instead, matching what CDuration#valid_value?
+      # already expects its range bounds to be.
+      def duration_range(range_xml)
+        lower = duration_bound(range_xml.at('lower'), range_xml.at('lower_unbounded'))
+        upper = duration_bound(range_xml.at('upper'), range_xml.at('upper_unbounded'))
+        return nil if lower.nil? && upper.nil?
+
+        OpenEHR::AssumedLibraryTypes::Interval.new(
+          lower: lower, upper: upper,
+          lower_included: lower.nil? ? nil : bool_node(range_xml.at('lower_included'), true),
+          upper_included: upper.nil? ? nil : bool_node(range_xml.at('upper_included'), true))
+      end
+
+      def duration_bound(value_node, unbounded_node)
+        return nil if bool_node(unbounded_node, false)
+        return nil if value_node.nil? || value_node.text.empty?
+
+        OpenEHR::RM::DataTypes::Quantity::DateTime::DvDuration.new(value: value_node.text)
+      end
+
+      def bool_node(node, default)
+        node ? to_bool(node.text) : default
+      end
+
+      def c_time(xml)
+        pattern = xml.at('pattern')
+        range = xml.at('range')
+        if pattern
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new(pattern: pattern.text)
+        elsif range
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new(range: occurrences(range))
+        else
+          OpenEHR::AM::Archetype::ConstraintModel::Primitive::CTime.new
+        end
+      end
+
       def c_boolean(xml)
         true_valid = xml.at('true_valid')
         false_valid = xml.at('false_valid')