openehr 1.1.0

data/lib/openehr.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__))
+
+module OpenEHR
+  VERSION = '1.0.3'
+  autoload :AssumedLibraryTypes, 'openehr/assumed_library_types'
+  autoload :RM, 'openehr/rm'
+  autoload :AM, 'openehr/am'
+  autoload :Terminology, 'openehr/terminology'
+  autoload :Serializer, 'openehr/serializer'
+  autoload :Parser, 'openehr/parser'
+end

data/lib/openehr/am.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__))
+
+module OpenEHR
+  module AM
+    autoload :Archetype, 'am/archetype'
+    autoload :OpenEHRProfile, 'am/openehr_profile'
+  end
+end

data/lib/openehr/am/archetype.rb

@@ -0,0 +1,133 @@
+$:.unshift(File.dirname(__FILE__))
+include OpenEHR::RM::Common::Resource
+
+module OpenEHR
+  module AM
+    module Archetype
+      autoload :Assertion, 'archetype/assertion'
+      autoload :ConstraintModel, 'archetype/constraint_model'
+      autoload :Ontology, 'archetype/ontology'
+
+      module ADLDefinition
+        include OpenEHR::RM::Support::Terminology
+#        include OpenEHR::RM::Support::Terminology::OpenEHR_Code_Set_Identifier
+        CURRENT_ADL_VERSION = "1.4"
+      end
+
+      class Archetype < AuthoredResource
+        include ADLDefinition
+        attr_reader :archetype_id, :concept, :definition, :ontology
+        attr_accessor :uid, :adl_version, :parent_archetype_id, :invariants
+
+        def initialize(args = {})
+          super(args)
+          self.adl_version = args[:adl_version] 
+          self.archetype_id = args[:archetype_id]
+          self.uid = args[:uid]
+          self.concept = args[:concept]
+          self.parent_archetype_id = args[:parent_archetype_id]
+          self.definition = args[:definition]
+          self.ontology = args[:ontology]
+          self.invariants = args[:invariants]
+        end
+
+        def archetype_id=(archetype_id)
+          if archetype_id.nil?
+            raise ArgumentError, 'archetype_id is mandatory'
+          end
+          @archetype_id = archetype_id
+        end
+
+        def concept=(concept)
+          if concept.nil?
+            raise ArgumentError, 'concept is mandatory'
+          end
+          @concept = concept
+        end
+
+        def definition=(definition)
+          if definition.nil?
+            raise ArgumentError, 'definition is mandatory'
+          end
+          @definition = definition
+        end
+
+        def ontology=(ontology)
+          if ontology.nil?
+            raise ArgumentError, 'ontology is mandatory'
+          end
+          @ontology = ontology
+        end
+
+        def version
+          return @archetype_id.version_id
+        end
+
+        def short_concept_name
+          return @archetype_id.concept_name
+        end
+
+        def concept_name(a_lang)
+          return @ontology.term_definition(:lang => a_lang, :code => @concept).items[:text]
+        end
+
+        def constraint_references_valid?
+        end
+
+        def internal_references_valid?
+        end
+
+        def is_specialised?
+        end
+
+        def is_valid?
+        end
+
+        def logical_paths(a_lang) 
+        end
+
+        def node_ids_vaild?
+        end
+
+        def physical_paths
+        end
+
+        def previous_version
+        end
+
+        def specialisation_depth
+        end
+        
+        def self.create(args ={}, &block)
+          archetype = new(args)
+          if block_given?
+            yield archetype
+          end
+          return archetype
+        end
+
+      end # end of Archetype
+      # original file:
+      # ref_imple_eiffel/components/adl_parser/src/interface/adl_definition.e
+
+      class ValidityKind
+        attr_reader :value
+
+        MANDATORY = 1001
+        OPTIONAL = 1002
+        DISALLOWED = 1003
+
+        def initialize(args = { })
+          self.value = args[:value]
+        end
+
+        def value=(value)
+          unless [MANDATORY, OPTIONAL, DISALLOWED].include? value
+            raise ArgumentError, 'invalid value'
+          end
+          @value = value
+        end
+      end
+    end # of Archetype
+  end # of AM
+end # of OpenEHR

data/lib/openehr/am/archetype/assertion.rb

@@ -0,0 +1,190 @@
+module OpenEHR
+  module AM
+    module Archetype
+      module Assertion
+        class Assertion
+          attr_reader :expression, :tag
+          attr_accessor :string_expression, :variables
+
+          def initialize(args = { })
+            self.expression = args[:expression]
+            self.tag = args[:tag]
+            self.string_expression = args[:string_expression]
+            self.variables = args[:variables]
+          end
+
+          def expression=(expression)
+            if expression.nil? or expression.type.upcase != 'BOOLEAN'
+              raise ArgumentError, 'invalid expression'
+            end
+            @expression = expression
+          end
+
+          def tag=(tag)
+            if !tag.nil? && tag.empty?
+              raise ArgumentError, 'tag should not be empty'
+            end
+            @tag = tag
+          end
+        end
+
+        class ExprItem
+          attr_reader :type
+
+          def initialize(args = { })
+            self.type = args[:type]
+          end
+
+          def type=(type)
+            if type.nil? or type.empty?
+              raise ArgumentError, 'type is mandatory'
+            end
+            @type = type
+          end
+        end
+
+        class ExprLeaf < ExprItem
+          attr_reader :item, :reference_type
+
+          def initialize(args = { })
+            super
+            self.item = args[:item]
+            self.reference_type = args[:reference_type]
+          end
+
+          def item=(item)
+            if item.nil?
+              raise ArgumentError, 'item is mandatory'
+            end
+            @item = item
+          end
+
+          def reference_type=(reference_type)
+            if reference_type.nil?
+              raise ArgumentError, 'reference_type is mandatory'
+            end
+            @reference_type = reference_type
+          end
+        end
+
+        class ExprOperator < ExprItem
+          attr_accessor :operator, :precedence_overridden
+
+          def initialize(args = { })
+            super
+            self.operator = args[:operator]
+            self.precedence_overridden = args[:precedence_overridden]
+          end
+        end
+
+        class ExprUnaryOperator < ExprOperator
+          attr_reader :operand
+
+          def initialize(args = { })
+            super
+            self.operand = args[:operand]
+          end
+
+          def operand=(operand)
+            if operand.nil?
+              raise ArgumentError, 'operand is mandatory'
+            end
+            @operand = operand
+          end
+        end
+
+        class ExprBinaryOperator < ExprOperator
+          attr_reader :right_operand, :left_operand
+
+          def initialize(args = { })
+            super
+            self.right_operand = args[:right_operand]
+            self.left_operand = args[:left_operand]
+          end
+
+          def right_operand=(right_operand)
+            if right_operand.nil?
+              raise ArgumentError, 'right_operand is mandatory'
+            end
+            @right_operand = right_operand
+          end
+
+          def left_operand=(left_operand)
+            if left_operand.nil?
+              raise ArgumentError, 'left_operand is mandatory'
+            end
+            @left_operand = left_operand
+          end
+        end
+
+        class AssertionVariable
+          attr_reader :name, :definition
+
+          def initialize(args = { })
+            self.name = args[:name]
+            self.definition = args[:definition]
+          end
+
+          def name=(name)
+            if name.nil?
+              raise ArgumentError, 'name is mandatory'
+            end
+            @name = name
+          end
+
+          def definition=(definition)
+            if definition.nil?
+              raise ArgumentError, 'definition is mandatory'
+            end
+            @definition = definition
+          end
+        end
+
+        class OperatorKind
+          OP_EQ = 2001
+          OP_NE = 2002
+          OP_LE = 2003
+          OP_LT = 2004
+          OP_GE = 2005
+          OP_GT = 2006
+          OP_MATCHES = 2007
+
+          OP_NOT = 2010
+          OP_AND = 2011
+          OP_OR = 2012
+          OP_XOR = 2013
+          OP_IMPLIES = 2014
+          OP_FOR_ALL = 2015
+          OP_EXISTS = 2016
+
+          OP_PLUS = 2020
+          OP_MINUS = 2021
+          OP_MULTIPLY = 2022
+          OP_DIVIDE = 2023
+          OP_EXP = 2024
+
+          attr_reader :value
+
+          def initialize(args = { })
+            self.value = args[:value]
+          end
+
+          def value=(value)
+            unless OperatorKind.valid_operator? value
+              raise ArgumentError, 'invalid value'
+            end
+            @value = value
+          end
+
+          def self.valid_operator?(value)
+            if value >= OP_EQ && value <= OP_EXP
+              return true
+            else
+              return false
+            end
+          end
+        end
+      end # of Assetion
+    end # of Archtype
+  end #of AM
+end # of OpenEHR

data/lib/openehr/am/archetype/constraint_model.rb

@@ -0,0 +1,328 @@
+$:.unshift(File.dirname(__FILE__))
+module OpenEHR
+  module AM
+    module Archetype
+      module ConstraintModel
+
+        autoload :Primitive, 'constraint_model/primitive'
+
+        class ArchetypeConstraint
+          attr_reader :path
+          attr_accessor :parent
+
+          def initialize(args = { })
+            self.path = args[:path]
+            self.parent = args[:parent]
+          end
+
+          def path=(path)
+            if path.nil?
+              raise ArgumentError, 'path is mandatory'
+            end
+            @path = path
+          end
+
+          def has_path?(path)
+            return @path.include?(path)
+          end
+
+          def congruent?
+            if @path.index(@parent.path) == 0
+              return true
+            else
+              return false
+            end
+          end
+
+          alias is_congruent? congruent?
+
+          def node_conforms_to?(other)
+            if @path.index(other.path) == 0
+              return true
+            else
+              return false
+            end
+          end
+        end
+
+        class Cardinality
+          attr_accessor :interval, :is_ordered, :is_unique
+
+          def initialize(args = { })
+            @interval = args[:interval]
+            @is_ordered = args[:is_ordered]
+            @is_unique = args[:is_unique]
+          end
+
+          def is_ordered?
+            return @is_ordered
+          end
+          
+          alias ordered? is_ordered?
+
+          def is_unique?
+            return @is_unique
+          end
+
+          alias unique? is_unique?
+
+          def is_set?
+            return !@is_ordered && @is_unique
+          end
+
+          alias set? is_set?
+
+          def is_list?
+            return @is_ordered && !@is_unique
+          end
+
+          alias list? is_list?
+
+          def is_bag?
+            return !@is_ordered && !@is_unique
+          end
+
+          alias bag? is_bag?
+        end
+
+        class CObject < ArchetypeConstraint
+          attr_reader :rm_type_name, :node_id, :occurrences
+
+          def initialize(args = { })
+            super
+            self.rm_type_name = args[:rm_type_name]
+            self.node_id = args[:node_id]
+            self.occurrences = args[:occurrences]
+          end
+
+          def rm_type_name=(rm_type_name)
+            if rm_type_name.nil? || rm_type_name.empty?
+              raise ArgumentError, 'invalid rm_type_name'
+            end
+            @rm_type_name = rm_type_name
+          end
+
+          def node_id=(node_id)
+            if !node_id.nil? && node_id.empty?
+              raise ArgumentError, 'invalid node_id'
+            end
+            @node_id = node_id
+          end
+
+          def occurrences=(occurrences)
+            if occurrences.nil?
+              raise ArgumentError, 'invaild occurrences'
+            end
+            @occurrences = occurrences
+          end
+
+          def self.create(args = { }, &block)
+            c_object = new(args)
+            if block_given?
+              yield c_object
+            end
+            return c_object
+          end
+        end
+
+        class CAttribute < ArchetypeConstraint
+          attr_reader :rm_attribute_name, :existence
+          attr_accessor :children
+
+          def initialize(args = { })
+            super(args)
+            self.rm_attribute_name = args[:rm_attribute_name]
+            self.existence = args[:existence]
+            self.children = args[:children]
+          end
+
+          def rm_attribute_name=(rm_attribute_name)
+            if rm_attribute_name.nil? or rm_attribute_name.empty?
+              raise ArgumentError, 'invalid rm_attribute_name'
+            end
+            @rm_attribute_name = rm_attribute_name
+          end
+
+          def existence=(existence)
+            if !existence.nil? && (existence.lower < 0 || existence.upper > 1)
+              raise ArgumentError, 'invalid existence'
+            end
+            @existence = existence
+          end
+        end
+
+        class CDefinedObject < CObject
+          attr_accessor :assumed_value
+          
+          def initialize(args = { })
+            super
+            self.assumed_value = args[:assumed_value]
+          end
+
+          def has_assumed_value?
+            return !@assumed_value.nil?
+          end
+
+          def default_value
+            raise NotImplementedError, 'subclass should implement this method'
+          end
+
+          def valid_value?(value)
+            raise NotImplementedError, 'subclass should implement this method'
+          end
+
+          def any_allowed?
+            raise NotImplementedError, 'subclass should implement this method'
+          end
+        end
+
+        class CPrimitiveObject < CDefinedObject
+          attr_accessor :item
+
+          def initialize(args = { })
+            super
+            self.item = args[:item]
+          end
+
+          def any_allowed?
+            return item.nil?
+          end
+        end
+
+        class CComplexObject < CDefinedObject
+          attr_accessor :attributes
+
+          def initialize(args = { })
+            super
+            self.attributes = args[:attributes]
+          end
+
+          def any_allowed?
+            return (@attributes.nil? or @attributes.empty?)
+          end
+
+          def self.create(args = { }, &block)
+            c_complex_object = new(args)
+            if block_given?
+              yield c_complex_object
+            end
+            return c_complex_object
+          end
+        end
+
+        class CDomainType < CDefinedObject
+          def standard_equivalent
+            raise NotImplementedError, 'subclass should be defined'
+          end
+        end
+
+        class CReferenceObject < CObject
+
+        end
+
+        class ArchetypeInternalRef < CReferenceObject
+          attr_reader :target_path
+
+          def initialize(args = { })
+            super
+            self.target_path = args[:target_path]
+          end
+
+          def target_path=(target_path)
+            if target_path.nil? or target_path.empty?
+              raise ArgumentError, 'target_path is mandatory'
+            end
+            @target_path = target_path
+          end
+        end
+
+        class ArchetypeSlot < CReferenceObject
+          attr_reader :includes, :excludes
+
+          def initialize(args = { })
+            super
+            self.includes = args[:includes]
+            self.excludes = args[:excludes]
+          end
+
+          def includes=(includes)
+            if !includes.nil? && includes.empty?
+              raise ArgumentError, 'includes should not be empty'
+            end
+            @includes = includes
+          end
+          
+          def excludes=(excludes)
+            if !excludes.nil? && excludes.empty?
+              raise ArgumentError, 'excludes should not be empty'
+            end
+            @excludes = excludes
+          end
+
+          def any_allowed?
+            return includes.nil? && excludes.nil?
+          end
+
+          def self.create(args = { }, &block)
+            archetype_slot = new(args)
+            archetype_slot.includes = args[:includes]
+            archetype_slot.excludes = args[:excludes]
+            if block_given?
+              yield archetype_slot
+            end
+            return archetype_slot
+          end
+        end
+
+        class ConstraintRef < CReferenceObject
+          attr_reader :reference
+
+          def initialize(args = { })
+            super
+            self.reference = args[:reference]
+          end
+
+          def reference=(reference)
+            if reference.nil?
+              raise ArgumentError, 'reference is mandatory'
+            end
+            @reference = reference
+          end
+
+          def self.create(args = { }, &block)
+            constraint_ref = new(args)
+            constraint_ref.reference = args[:reference]
+            if block_given?
+              yield constraint_ref
+            end
+            return constraint_ref
+          end
+        end
+
+        class CSingleAttribute < CAttribute
+          attr_reader :alternatives
+
+          def initialize(args = { })
+            super
+            self.alternatives = args[:alternatives]
+          end
+
+          def alternatives=(alternatives)
+            @alternatives = alternatives
+          end
+        end
+
+        class CMultipleAttribute < CAttribute
+          attr_accessor :members, :cardinality
+          
+          def initialize(args = { })
+            super
+            self.members = args[:members]
+            self.cardinality = args[:cardinality]
+          end
+        end
+      end # of ConstraintModel
+    end # of Archetype
+  end # of AM
+end # of OpenEHR
+