open_ehr 0.6.1

data/lib/open_ehr/rm/data_types/charset_extract.rb

@@ -0,0 +1,24 @@
+#! /usr/bin/env ruby
+# charactor sets extraction from download file from
+# http://www.iana.org/assignments/character-sets
+# as character-sets
+
+class CharacterSets
+  def self.get_list
+    list = Array.new
+    open('character-sets') do |file|
+      while line = file.gets
+        if /^((Name:)|(Alias:)) (\S+)/ =~ line
+          list << $4 unless $4 == "None"
+        end
+      end
+    end
+    return list
+  end
+end
+
+open('charset.lst','w') do |f|
+  CharacterSets.get_list.each do |line|
+    f.puts(line)
+  end
+end

data/lib/open_ehr/rm/data_types/encapsulated.rb

@@ -0,0 +1,98 @@
+# OpenEHR::RM::Data_Types::Encapsulated 
+# http://www.openehr.org/svn/specification/TAGS/Release-1.0.2/publishing/architecture/computable/UML/uml_start_view.html
+# refs #51
+require 'rubygems'
+require 'locale/info'
+
+module OpenEHR
+  module RM
+    module DataTypes
+      module Encapsulated
+        class DvEncapsulated  < OpenEHR::RM::DataTypes::Basic::DataValue
+          attr_reader :language, :charset
+
+          def initialize(args = {})
+            super(args)
+            self.charset = args[:charset]
+            self.language = args[:language]
+          end
+
+          def size
+            @value.size
+          end
+
+          def language=(language)
+            if !language.nil? &&
+                !Locale::Info.language_code?(language.code_string)
+              raise ArgumentError, 'invalid language code'
+            end
+            @language = language
+          end
+
+          def charset=(charset)
+            if !charset.nil? && !charset_valid?(charset.code_string)
+              raise ArgumentError, 'invalid charset'
+            end
+            @charset = charset
+          end
+
+          private
+
+          def charset_valid?(charset)
+            result = false
+            open('lib/open_ehr/rm/data_types/charset.lst') do |file|
+              while line = file.gets
+                if charset == line.chomp
+                  result = true
+                  break
+                end
+              end
+            end
+            return result
+          end
+        end
+
+# media type http://www.iana.org/assignments/media-types/text/
+        class DvMultimedia < DvEncapsulated
+          attr_reader :media_type
+          attr_accessor :uri, :data, :compression_algorithm,
+          :integrity_check, :integrity_check_algorithm, :alternate_text
+
+          def initialize(args = {})
+            super(args)
+            self.media_type = args[:media_type]
+            self.uri = args[:uri]
+            self.data = args[:data]
+            self.compression_algorithm = args[:compression_algorithm]
+            self.integrity_check = args[:integrity_check]
+            self.integrity_check_algorithm = args[:integrity_check_algorithm]
+            self.alternate_text = args[:alternate_text]
+          end
+
+          def media_type=(media_type)
+            if media_type.code_string.nil?
+              raise ArgumentError, 'media_type should not be nil'
+            end
+            @media_type = media_type
+          end
+        end
+
+        class DvParsable < DvEncapsulated
+          attr_reader :formalism
+
+          def initialize(args = {})
+            super(args)
+            self.formalism = args[:formalism]
+          end
+
+          def formalism=(formalism)
+            if formalism.nil? || formalism.empty?
+              raise ArgumentError, 'formalism is mandatory'
+            end
+            @formalism = formalism
+          end
+        end
+      end # of Encapsulated
+    end # of DataTypes
+  end # of RM
+end # of OpenEHR

data/lib/open_ehr/rm/data_types/quantity/date_time.rb

@@ -0,0 +1,229 @@
+# This module is implementation of the UML:
+# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109696321450_28117_5362Report.html
+# Ticket refs #49
+#require 'assumed_library_types'
+require 'date'
+include OpenEHR::RM::DataTypes::Quantity
+include OpenEHR::AssumedLibraryTypes
+
+module OpenEHR
+  module RM
+    module DataTypes
+      module Quantity
+        module DateTime
+          class DvTemporal < DvAbsoluteQuantity
+            def initialize(args = {})
+              self.value = args[:value]
+              self.magnitude_status = args[:magnitude_status]
+              self.accuracy = args[:accuracy]
+              self.normal_range = args[:normal_range]
+              self.normal_status = args[:normal_status]
+              self.other_reference_ranges = args[:other_reference_ranges]
+            end
+
+            def value=(value)
+              if value.nil? or value.empty?
+                raise ArgumentError, 'invalid value'
+              end
+              @value = value
+            end
+
+            undef magnitude=
+          end
+
+          class DvDate < DvTemporal
+            include ISO8601DateModule
+
+            DAYS_IN_MONTH = [0,31,28,31,30,31,30,31,31,30,31,30,31]
+
+            def value=(value)
+              super(value)
+              iso8601_date = ISO8601Date.new(value)
+              @year = iso8601_date.year
+              @month = iso8601_date.month
+              @day = iso8601_date.day
+            end
+
+            def magnitude
+              return Date.new(@year, @month, @day)-Date.new(0000,1,1)
+            end
+
+            def diff(other)
+              if self.magnitude > other.magnitude
+                past, future = other, self
+              else
+                past, future = self, other
+              end
+              year, month, day = 0, 0, 0
+              if (future.day >= past.day)
+                day = future.day - past.day
+              else
+                month = -1
+                previous_month = future.month - 1
+                if previous_month == 0
+                  previous_month = 12
+                end
+                day = DAYS_IN_MONTH[previous_month] + future.day - past.day
+                if leapyear?(future.year) && (previous_month == 2)
+                  day += 1
+                end
+              end
+              week = day / 7
+              if (future.month >= past.month)
+                month += future.month - past.month
+              else
+                year -= 1
+                month += future.month + 12 - past.month
+              end
+              if month < 0
+                year -= 1
+                month += 12
+              end
+              year += future.year - past.year
+              return DvDuration.new(:value =>
+                   'P' + year.to_s + 'Y' + month.to_s + 'M' + 
+                         week.to_s + 'W' + day.to_s + 'D')
+            end
+          end
+          
+          class DvTime < DvTemporal
+            include ISO8601TimeModule
+
+            def value=(value)
+              super(value)
+              iso8601_time = ISO8601Time.new(value)
+              @hour = iso8601_time.hour
+              @minute = iso8601_time.minute
+              @second = iso8601_time.second
+              @fractional_second = iso8601_time.fractional_second
+            end
+
+            def magnitude
+              if @fractional_second.nil?
+                return @hour * 60 * 60 + @minute * 60 + @second
+              else
+                return @hour * 60 * 60 + @minute * 60 + @second + @fractional_second
+              end
+            end
+
+            def diff(other)
+              diff = (other.magnitude - self.magnitude).abs
+              hour = (diff / 60 / 60).to_i
+              minute = ((diff - hour*60*60)/60).to_i
+              second = (diff - hour * 60 *60 - minute * 60).to_i
+              fractional_second = ((diff - diff.to_i)*1000000.0).to_i/1000000.0
+              str = 'P0Y0M0W0DT' + hour.to_s + 'H' +
+                minute.to_s + 'M' + second.to_s
+              if @fractional_second.nil?
+                str += 'S'
+              else
+                str += fractional_second.to_s[1..-1] + 'S'
+              end
+              return DvDuration.new(:value => str)
+            end
+          end
+
+          class DvDateTime < DvTemporal
+            include OpenEHR::AssumedLibraryTypes::ISO8601DateTimeModule
+
+            def value=(value)              
+              super(value)
+              iso8601date_time = AssumedLibraryTypes::ISO8601DateTime.new(value)
+              self.year = iso8601date_time.year
+              self.month = iso8601date_time.month
+              self.day = iso8601date_time.day
+              self.minute = iso8601date_time.minute
+              self.second = iso8601date_time.second
+              self.hour = iso8601date_time.hour
+              self.fractional_second = iso8601date_time.fractional_second
+              self.timezone = iso8601date_time.timezone
+            end
+
+            def magnitude
+              seconds = (((@year * 365.24 +
+                           @month * 30.42 +
+                           @day) * 24 + @hour) * 60 +
+                         @minute) * 60 + @second
+              if @fractional_second.nil?
+                return seconds
+              else
+                return seconds + @fractional_second
+              end
+            end
+
+            def diff(other)
+              if self.magnitude >= other.magnitude
+                past, future = other, self
+              else
+                past, future = self, other
+              end
+              past_date, past_time = split_date_time(past)
+              future_date, future_time = split_date_time(future)
+              time_diff = future_time.magnitude - past_time.magnitude
+              if future_time.magnitude < past_time.magnitude
+                future_date.day = future_date.day - 1
+                time_diff += 24 * 60 * 60
+              end
+              date_duration = past_date.diff(future_date)
+              hour = (time_diff / 60 / 60).to_i
+              minute = ((time_diff - hour*60*60)/60).to_i
+              second = (time_diff - hour * 60 *60 - minute * 60).to_i
+              str = date_duration.value + 'T' + hour.to_s + 'H' +
+                minute.to_s + 'M' + second.to_s
+              if @fractional_second.nil?
+                return DvDuration.new(:value => str +'S')
+              else
+                fractional_second =
+                  ((time_diff - time_diff.to_i)*1000000.0).to_i/1000000.0
+                return DvDuration.new(:value => str +
+                                      fractional_second.to_s[1..-1] + 'S')
+              end
+            end
+
+            private
+            def split_date_time(date_time)
+              /^(.*)T(.*)$/ =~ date_time.as_string
+              return DvDate.new(:value => $1), DvTime.new(:value => $2)
+            end
+          end
+
+          class DvDuration < DvAmount
+            include AssumedLibraryTypes::ISO8601DurationModule
+            attr_reader :value
+            
+            def initialize(args = { })
+              self.value = args[:value]
+              self.magnitude_status = args[:magnitude_status]
+              self.normal_range = args[:normal_range]
+              self.normal_status = args[:normal_status]
+              self.other_reference_ranges = args[:other_reference_ranges]
+            end
+
+            def value=(value)
+              raise ArgumentError, 'value must be not nil' if value.nil?
+              @value = value
+              iso8601_duration = AssumedLibraryTypes::ISO8601Duration.new(value)
+              self.years = iso8601_duration.years
+              self.months = iso8601_duration.months
+              self.weeks = iso8601_duration.weeks
+              self.days = iso8601_duration.days
+              self.hours = iso8601_duration.hours
+              self.minutes = iso8601_duration.minutes
+              self.seconds = iso8601_duration.seconds
+              self.fractional_second = iso8601_duration.fractional_second
+            end
+
+            def magnitude
+              return ((((@year + @month/MONTH_IN_YEAR)*NOMINAL_DAYS_IN_MONTH) +
+                @week * DAYS_IN_WEEK + @days) * HOURS_IN_DAY * MINUTES_IN_HOUR*
+                SECONDS_IN_MINUTE) + @second + @fractional_second
+            end
+            
+            undef magnitude=
+
+          end
+        end # of DateTime
+      end # of Quantity
+    end # of Data_Types
+  end # of RM
+end # of OpenEHR