open_ehr 0.6.1

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

@@ -0,0 +1,340 @@
+$:.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(args)
+            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)
+            if alternatives.nil?
+              raise ArgumentError, 'alternatives are mandatory'
+            end
+            @alternatives = alternatives
+          end
+        end
+
+        class CMultipleAttribute < CAttribute
+          attr_accessor :members
+          attr_reader :cardinality
+          
+          def initialize(args = { })
+            super
+            self.members = args[:members]
+            self.cardinality = args[:cardinality]
+          end
+
+          def cardinality=(cardinality)
+            if cardinality.nil?
+              raise ArgumentError, 'cardinality is mandatory'
+            end
+            @cardinality = cardinality
+          end
+        end
+      end # of ConstraintModel
+    end # of Archetype
+  end # of AM
+end # of OpenEHR
+  

data/lib/open_ehr/am/archetype/ontology.rb

@@ -0,0 +1,97 @@
+module OpenEHR
+  module AM
+    module Archetype
+      module Ontology
+        class ArchetypeOntology
+          attr_accessor :constraint_definitions, :specialisation_depth
+          attr_accessor :term_attribute_names, :term_bindings
+          attr_reader :terminologies_available, :term_definitions
+
+          def initialize(args = { })
+            self.specialisation_depth = args[:specialisation_depth]
+            self.term_definitions = args[:term_definitions]
+            self.constraint_definitions = args[:constraint_definitions]
+            self.term_bindings = args[:term_bindings]
+          end
+
+          def term_definitions=(term_definitions)
+            if term_definitions.nil?
+              raise ArgumentError, 'term_definitions is mandatory'
+            end
+            @term_definitions = term_definitions
+          end
+
+          def term_codes
+            return @term_definitions.values.collect {|value|
+              value.collect {|term| term.code}}.flatten.uniq
+          end
+
+          def constraint_codes
+            if @constraint_definitions.nil?
+              return nil
+            else
+              return @constraint_definitions.values.collect {|value|
+                value.collect {|term| term.code}}.flatten.uniq
+            end
+          end
+
+          def terminologies_available
+            return @term_bindings.keys
+          end
+
+          def constraint_binding(a_terminology, a_code)
+          end
+
+          def constraint_definition(a_lang, a_code)
+          end
+
+          def has_language?(a_lang)
+          end
+
+          def has_terminology?(a_terminology)
+          end
+
+          def term_binding(a_terminology, a_code)
+          end
+
+          def term_definition(a_lang, a_code)
+          end
+        end
+
+        class ARCHETYPE_ONTOLOGY < ArchetypeOntology
+
+        end
+
+        class ArchetypeTerm
+          attr_accessor :items
+          attr_reader :code
+
+          def initialize(args = { })
+            self.code = args[:code]
+            self.items =args[:items]
+          end            
+
+          def code=(code)
+            if code.nil? or code.empty?
+              raise ArgumentError, 'code is mandatory'
+            end
+            @code = code
+          end
+
+          def keys
+            if items.nil?
+              return Set.new
+            else
+              return Set.new(@items.keys)
+            end
+          end
+        end
+
+        class ARCHETYPE_TERM < ArchetypeTerm
+
+        end
+      end # end of Ontology
+    end # end of Archetype
+  end # end of AM
+end # end of OpenEHR
+

data/lib/open_ehr/am/archetype.rb

@@ -0,0 +1,134 @@
+$:.unshift(File.dirname(__FILE__))
+include OpenEHR::RM::Common::Resource
+
+module OpenEHR
+  module AM
+    module Archetype
+      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)
+          
+        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
+
+      autoload :Assertion, 'archetype/assertion'
+      autoload :ConstraintModel, 'archetype/constraint_model'
+      autoload :Ontology, 'archetype/ontology'
+
+    end # of Archetype
+  end # of AM
+end # of OpenEHR

data/lib/open_ehr/am/open_ehr_profile/data_types/basic.rb

@@ -0,0 +1,29 @@
+module OpenEhr
+  module AM
+    module OpenEHR_Profile
+      module DataTypes
+        module Basic
+          class C_DV_STATE
+          end
+
+          class STATE_MACHINE
+          end
+
+          class STATE
+          end
+
+          class TERMINAL_STATE < STATE
+          end
+
+          class NON_TERMINAL_STATE < STATE
+          end
+
+          class TRANSITION
+          end
+        end
+
+        
+      end # of Data_Types
+    end # of OpenEHR Profile
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/am/open_ehr_profile/data_types/quantity.rb

@@ -0,0 +1,19 @@
+module OpenEhr
+  module AM
+    module OpenEHR_Profile
+      module DataTypes
+
+        module Quantity
+          class C_DV_QUANTITY < OpenEhr::AM::Archetype::Constraint_Model::C_DOMAIN_TYPE
+          end
+          
+          class C_DV_ORDINAL < OpenEhr::AM::Archetype::Constraint_Model::C_DOMAIN_TYPE
+          end
+
+          class C_QUANTITY_ITEM
+          end
+        end
+      end # of Data_Types
+    end # of OpenEHR Profile
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/am/open_ehr_profile/data_types/text.rb

@@ -0,0 +1,12 @@
+module OpenEhr
+  module AM
+    module OpenEHR_Profile
+      module DataTypes
+        module Text
+          class C_CODE_PHASE < OpenEhr::AM::Archetype::Constraint_Model::C_DOMAIN_TYPE
+          end
+        end
+      end # of Data_Types
+    end # of OpenEHR Profile
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/am.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module OpenEHR
+  module AM
+    autoload :Archetype, 'am/archetype'
+  end
+end