open_ehr 0.6.1

data/lib/open_ehr/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/open_ehr/am/archetype/constraint_model/primitive.rb

@@ -0,0 +1,296 @@
+# Ticket #71
+module OpenEHR
+  module AM
+    module Archetype
+      module ConstraintModel
+        module Primitive
+          class CPrimitive
+            attr_reader :default_value
+            attr_accessor :assumed_value
+
+            def initialize(args = { })
+              self.default_value = args[:default_value]
+              self.assumed_value = args[:assumed_value]
+            end
+
+            def default_value=(default_value)
+              if default_value.nil?
+                raise ArgumentError, 'default_value is mandatory'
+              end
+              @default_value = default_value
+            end
+
+            def has_assumed_value?
+              return !assumed_value.nil?
+            end
+          end
+
+          class CBoolean < CPrimitive
+            attr_reader :true_valid, :false_valid
+
+            def initialize(args = { })
+              binary_consistency(args[:true_valid], args[:false_valid])
+              @true_valid = args[:true_valid]
+              @false_valid = args[:false_valid]
+              super(args)
+            end
+
+            def default_value=(default_value)
+              super
+              default_value_consistency(default_value)
+            end
+
+            def true_valid=(true_valid)
+              binary_consistency(true_valid, @false_valid)
+              @true_valid = true_valid
+            end
+
+            def false_valid=(false_valid)
+              binary_consistency(@true_valid, false_valid)
+              @false_valid = false_valid
+            end
+
+            def true_valid?
+              return @true_valid
+            end
+
+            def false_valid?
+              return @false_valid
+            end
+
+            private
+            def binary_consistency(true_valid, false_valid)
+              if (true_valid == false) && (false_valid == false)
+                raise ArgumentError, 'true_valid or false_valid should be true'
+              end
+            end
+
+            def default_value_consistency(default_value)
+              if (!@true_valid && default_value) || (!@false_valid && !default_value)
+                raise ArgumentError, 'default value inconsistency'
+              end
+            end
+          end
+
+          class CString < CPrimitive
+            attr_reader :pattern, :list
+
+            def initialize(args = { })
+              super
+              consistency(args[:pattern], args[:list])
+              @pattern = args[:pattern]
+              @list = args[:list]
+            end
+
+            def pattern=(pattern)
+              consistency(pattern, @list)
+              @pattern = pattern
+            end
+
+            def list=(list)
+              consistency(@pattern, list)
+              @list = list
+            end
+
+            private
+            def consistency(pattern, list)
+              if pattern.nil? == list.nil?
+                raise ArgumentError, 'consistency invaild'
+              end
+            end
+          end
+
+          class CInteger < CPrimitive
+            attr_reader :list, :range
+
+            def initialize(args = { })
+              super
+              consistency(args[:list], args[:range])
+              @list = args[:list]
+              @range = args[:range]
+            end
+
+            def list=(list)
+              consistency(list, @range)
+              @list = list
+            end
+
+            def range=(range)
+              consistency(@list, range)
+              @range = range
+            end
+
+            private
+            def consistency(list, range)
+              if list.nil? == range.nil?
+                raise ArgumentError, 'consistency invalid'
+              end
+            end
+          end
+
+          class CReal < CInteger
+
+          end
+
+          module CDateModule
+            attr_accessor :range, :timezone_validity
+            attr_reader :month_validity, :day_validity
+
+            def month_validity=(month_validity)
+              if (month_validity == ValidityKind::OPTIONAL &&
+                  !(@day_validity == ValidityKind::OPTIONAL ||
+                    @day_validity == ValidityKind::DISALLOWED)) ||
+                  (month_validity == ValidityKind::DISALLOWED &&
+                  !(@day_validity == ValidityKind::DISALLOWED))
+                raise ArgumentError, 'month validity disallowed'
+              end
+              @month_validity = month_validity
+            end
+
+            def day_validity=(day_validity)
+              @day_validity = day_validity
+            end
+
+            def validity_is_range?
+              return !@range.nil?
+            end
+
+            private
+            def consistency_validity(month_validity, day_validity)
+            end
+          end
+
+          class CDate < CPrimitive
+            include CDateModule
+
+            def initialize(args = { })
+              super(args)
+              self.range = args[:range]
+              self.timezone_validity = args[:timezone_validity]
+              self.day_validity = args[:day_validity]
+              self.month_validity = args[:month_validity]
+            end
+          end
+
+          module CTimeModule
+            attr_accessor :range
+            attr_reader :minute_validity, :second_validity,
+                        :millisecond_validity
+
+            def minute_validity=(minute_validity)
+              if (minute_validity == ValidityKind::OPTIONAL &&
+                  @second_validity == ValidityKind::MANDATORY) ||
+                  (minute_validity == ValidityKind::DISALLOWED &&
+                   @second_validity != ValidityKind::DISALLOWED)
+                raise ArgumentError, 'minute_validity is invalid'
+              end
+              @minute_validity = minute_validity
+            end
+
+            def second_validity=(second_validity)
+              if (second_validity == ValidityKind::OPTIONAL &&
+                  @millisecond_validity == ValidityKind::MANDATORY) ||
+                  (second_validity == ValidityKind::DISALLOWED &&
+                   @millisecond_validity != ValidityKind::DISALLOWED)
+                raise ArgumentError, 'second_validity is invalid'
+              end
+              @second_validity = second_validity
+            end
+
+            def millisecond_validity=(millisecond_validity)
+              @millisecond_validity = millisecond_validity
+            end
+
+            def validity_is_range?
+              return !@range.nil?
+            end
+          end
+
+          class CTime < CPrimitive
+            include CTimeModule
+
+            def initialize(args = { })
+              super
+              self.range = args[:range]
+              self.millisecond_validity = args[:millisecond_validity]
+              self.second_validity = args[:second_validity]
+              self.minute_validity = args[:minute_validity]
+            end
+          end
+
+          class CDateTime < CPrimitive
+            include CDateModule, CTimeModule
+            attr_reader :hour_validity
+
+            def initialize(args = { })
+              super
+              self.timezone_validity = args[:timezone_validity]
+              self.millisecond_validity = args[:millisecond_validity]
+              self.second_validity = args[:second_validity]
+              self.minute_validity = args[:minute_validity]
+              self.hour_validity = args[:hour_vaildity]
+              self.day_validity = args[:day_validity]
+              self.month_validity = args[:day_validity]
+            end
+
+            def hour_validity=(hour_validity)
+              if (hour_validity == ValidityKind::DISALLOWED &&
+                  @minute_validity != ValidityKind::DISALLOWED) ||
+                  (hour_validity == ValidityKind::OPTIONAL &&
+                   !(@minute_validity == ValidityKind::OPTIONAL ||
+                     @minute_validity == ValidityKind::DISALLOWED))
+                raise ArgumentError, 'hour_validity is invalid'
+              end
+              @hour_validity = hour_validity
+            end
+
+            def day_validity=(day_validity)
+              if (day_validity == ValidityKind::DISALLOWED &&
+                  @hour_validity != ValidityKind::DISALLOWED) ||
+                  (day_validity == ValidityKind::OPTIONAL &&
+                   !(@hour_validity == ValidityKind::OPTIONAL ||
+                     @hour_validity == ValidityKind::DISALLOWED))
+                raise ArgumentError, 'day_validity is invaild'
+              end
+              @day_validity = day_validity
+            end
+          end
+
+          class CDuration < CPrimitive
+            attr_reader :range
+            attr_accessor :years_allowed, :months_allowed, :weeks_allowed,
+                          :days_allowed, :hours_allowed, :minutes_allowed,
+                          :seconds_allowed, :fractional_seconds_allowed
+
+            def initialize(args = { })
+              super
+              self.fractional_seconds_allowed = args[:fractional_seconds_allowed]
+              self.seconds_allowed = args[:seconds_allowed]
+              self.minutes_allowed = args[:minutes_allowed]
+              self.hours_allowed = args[:hours_allowed]
+              self.days_allowed = args[:days_allowed]
+              self.months_allowed = args[:months_allowed]
+              self.weeks_allowed = args[:weeks_allowed]
+              self.years_allowed = args[:years_allowed]
+              self.range = args[:range]
+            end
+
+            def range=(range)
+              if range.nil? && !(@years_allowed ||
+                    @months_allowed ||
+                    @weeks_allowed ||
+                    @days_allowed ||
+                    @hours_allowed ||
+                    @minutes_allowed ||
+                    @seconds_allowed ||
+                    @fractional_seconds_allowed)
+                raise ArgumentError, 'invalid range'
+              end
+              @range = range
+            end
+          end
+        end # of Primitive
+      end # of CostraintModel
+    end # of Archetype
+  end # of AM
+end # of OpenEHR