Ignore:
Timestamp:
Sep 25, 2009, 12:15:59 PM (15 years ago)
Author:
KOBAYASHI, Shinji
Message:

hand merge

Location:
ruby/trunk/lib/open_ehr/rm/data_types
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • ruby/trunk/lib/open_ehr/rm/data_types/basic.rb

    r167 r297  
    22# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109067591791_562382_3151Report.html
    33# Ticket refs #52
    4 module OpenEhr
     4module OpenEHR
    55  module RM
    66    module DataTypes
    … …  
    1010
    1111        class DataValue
    12           include OpenEhr::RM::Support::Definition::BasicDefinition
     12          include OpenEHR::RM::Support::Definition::BasicDefinition
     13          attr_accessor :value
     14          alias :v :value
     15
     16          def initialize(args = {})
     17            self.value = args[:value]
     18          end
     19
     20          def ==(other)
     21            return self.value == other.value
     22          end
    1323        end
    1424
    1525        class DvBoolean < DataValue
    16           def initialize(value)
    17             self.value = value
     26          def initialize(args)
     27            super(args)
    1828          end
     29
    1930          def value=(value)
    2031            raise ArgumentError, "value must not be nil" if value.nil?
    … …  
    2536            end
    2637          end
     38
    2739          def value?
    2840            @value == true
    … …  
    3143
    3244        class DvState < DataValue
    33           attr_reader :value
     45          attr_reader :is_terminal
    3446
    35           def initialize(value, is_terminal)
    36             self.value=value
    37             self.is_terminal=is_terminal
     47          def initialize(args)           
     48            super(args)
     49            self.is_terminal = args[:is_terminal]
    3850          end
     51
    3952          def value=(v)
    4053            raise ArgumentError, "value should not be nil" if v.nil?
    4154            @value = v
    4255          end
     56
    4357          def is_terminal?
    4458            @is_terminal
    4559          end
     60
    4661          def is_terminal=(s)
    4762            raise ArgumentError, "terminal should not be nil" if s.nil?
    … …  
    5065        end # end of DvState
    5166
    52         class DvIdentifier
    53           attr_accessor :issuer, :assigner, :id, :type
    54           def initialize(assigner, id, issuer, type)
    55             if assigner.nil? or assigner.empty?\
    56               or id.nil? or id.empty? or issuer.nil? or issuer.empty?\
    57               or type.nil? or type.empty?
    58               raise ArgumentError, "invalid argument"
     67        class DvIdentifier < DataValue
     68          attr_reader :issuer, :assigner, :id, :type
     69
     70          def initialize(args = {})
     71            self.issuer = args[:issuer]
     72            self.assigner = args[:assigner]
     73            self.id = args[:id]
     74            self.type = args[:type]
     75          end
     76
     77          def issuer=(issuer)
     78            if issuer.nil? or issuer.empty?
     79              raise ArgumentError, 'issuer is mandatory'
    5980            end
    6081            @issuer = issuer
     82          end
     83
     84          def assigner=(assigner)
     85            if assigner.nil? or assigner.empty?
     86              raise ArgumentError, 'assigner is mandatory'
     87            end
    6188            @assigner = assigner
     89          end
     90
     91          def id=(id)
     92            if id.nil? or id.empty?
     93              raise ArgumentError, 'id is manadtory'
     94            end
    6295            @id = id
     96          end
     97
     98          def type=(type)
     99            if type.nil? or type.empty?
     100              raise ArgumentError, 'type is mandatory'
     101            end
    63102            @type = type
    64103          end

  • ruby/trunk/lib/open_ehr/rm/data_types/encapsulated.rb

    r167 r297  
    55require 'locale/info'
    66
    7 module OpenEhr
     7module OpenEHR
    88  module RM
    99    module DataTypes
    1010      module Encapsulated
    11         class DvEncapsulated  < OpenEhr::RM::DataTypes::Basic::DataValue
    12           attr_reader :language, :charset, :size
    13           def initialize(charset, language, size)
    14             self.charset = charset
    15             self.language = language
    16             self.size = size
     11        class DvEncapsulated  < OpenEHR::RM::DataTypes::Basic::DataValue
     12          attr_reader :language, :charset
     13
     14          def initialize(args = {})
     15            super(args)
     16            self.charset = args[:charset]
     17            self.language = args[:language]
    1718          end
    1819
    19           def size=(size)
    20             if size < 0
    21               raise ArgumentError, "negative size"
    22             end
    23             @size = size
     20          def size
     21            @value.size
    2422          end
    2523
    2624          def language=(language)
    27             if language.nil? ||
     25            if !language.nil? &&
    2826                !Locale::Info.language_code?(language.code_string)
    2927              raise ArgumentError, 'invalid language code'
    … …  
    3331
    3432          def charset=(charset)
    35             if charset.nil? || !charset_valid?(charset.code_string)
     33            if !charset.nil? && !charset_valid?(charset.code_string)
    3634              raise ArgumentError, 'invalid charset'
    3735            end
    … …  
    4038
    4139          private
    42           def size_positive
    43             raise ArgumentError, "size must be positive" if size < 0
    44           end
    4540
    4641          def charset_valid?(charset)
    4742            result = false
    48             open('rm/data_types/charset.lst') do |file|
     43            open('lib/open_ehr/rm/data_types/charset.lst') do |file|
    4944              while line = file.gets
    5045                if charset == line.chomp
    … …  
    6358          attr_accessor :uri, :data, :compression_algorithm,
    6459          :integrity_check, :integrity_check_algorithm, :alternate_text
    65           def initialize(charset, language, size, media_type, uri=nil,
    66                          data=nil, compression_algorithm=nil,
    67                          integrity_check=nil, integrity_check_algorithm=nil,
    68                          alternate_text=nil)
    69             super(charset, language, size)
    70             self.media_type = media_type
    71             @uri = uri
    72             @data = data
    73             @compression_algorithm = compression_algorithm
    74             @integrity_check = integrity_check
    75             @integrity_check_algorithm = integrity_check_algorithm
    76             @alternate_text = alternate_text
     60
     61          def initialize(args = {})
     62            super(args)
     63            self.media_type = args[:media_type]
     64            self.uri = args[:uri]
     65            self.data = args[:data]
     66            self.compression_algorithm = args[:compression_algorithm]
     67            self.integrity_check = args[:integrity_check]
     68            self.integrity_check_algorithm = args[:integrity_check_algorithm]
     69            self.alternate_text = args[:alternate_text]
    7770          end
     71
    7872          def media_type=(media_type)
    7973            if media_type.code_string.nil?
    … …  
    8579
    8680        class DvParsable < DvEncapsulated
    87           attr_reader :value, :formalism
    88           def initialize(charset, language, size, formalism, value)
    89             super(charset, language, size)
    90             self.formalism = formalism
    91             self.value = value
    92           end
     81          attr_reader :formalism
    9382
    94           def value=(value)
    95             raise ArgumentError, 'value must not be nil' if value.nil?
    96             @value = value
     83          def initialize(args = {})
     84            super(args)
     85            self.formalism = args[:formalism]
    9786          end
    9887
    9988          def formalism=(formalism)
    100             if formalism.nil?
    101               raise ArgumentError, "formalism must not be nil"
    102             elsif formalism.empty?
    103               raise ArgumentError, "formalism must nto be empty"
     89            if formalism.nil? || formalism.empty?
     90              raise ArgumentError, 'formalism is mandatory'
    10491            end
    10592            @formalism = formalism

  • ruby/trunk/lib/open_ehr/rm/data_types/quantity.rb

    r167 r297  
    33# Ticket refs #50
    44require 'assumed_library_types'
    5 module OpenEhr
     5module OpenEHR
    66  module RM
    77    module DataTypes
    … …  
    1010        autoload :Date_Time, "rm/data_types/quantity/date_time.rb"
    1111
    12         class DvOrdered < OpenEhr::RM::DataTypes::Basic::DataValue
     12        class DvOrdered < OpenEHR::RM::DataTypes::Basic::DataValue
    1313          include Comparable
    1414          attr_accessor :normal_range, :other_refference_ranges, :normal_status
    … …  
    5151        end
    5252
    53         class DvInterval < OpenEhr::AssumedLibraryTypes::Interval
     53        class DvInterval < OpenEHR::AssumedLibraryTypes::Interval
    5454
    5555        end

  • ruby/trunk/lib/open_ehr/rm/data_types/text.rb

    r167 r297  
    22# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109067605961_209522_3179Report.html
    33# Ticket refs #48
    4 module OpenEhr
     4module OpenEHR
    55  module RM
    66    module DataTypes
    … …  
    6262        end # of CodePhrase
    6363
    64         class DvText < OpenEhr::RM::DataTypes::Basic::DataValue
     64        class DvText < OpenEHR::RM::DataTypes::Basic::DataValue
    6565          attr_reader :value, :formatting, :hyperlink, :mappings
    6666          attr_reader :language, :encoding
    … …  
    146146        end
    147147
    148         class DvParagraph < OpenEhr::RM::DataTypes::Basic::DataValue
     148        class DvParagraph < OpenEHR::RM::DataTypes::Basic::DataValue
    149149          attr_reader :items
    150150          def initialize(items)

  • ruby/trunk/lib/open_ehr/rm/data_types/uri.rb

    r167 r297  
    44
    55require 'uri'
    6 #require 'uri/generic'
    7 module Uri
    8   class Ehr < ::URI::Generic
     6
     7module URI
     8  class EHR < ::URI::Generic
    99    COMPONENT = [
    1010      :scheme, :path, :fragment, :query
    1111    ].freeze
     12
    1213    def self.build(args)
    1314      tmp = Util::make_components_hash(self, args)
    1415      super(tmp)
    1516    end
     17
    1618    def initialize(*arg)
    1719      super(*arg)
    1820    end
     21
    1922    def self.use_registry
    2023      true
    2124    end
    2225  end
    23   @@schemes['EHR'] = Ehr
     26  @@schemes['EHR'] = EHR
    2427end
    2528
    26 module OpenEhr
     29module OpenEHR
    2730  module RM
    2831    module DataTypes
    2932      module Uri
    30         class DvUri < OpenEhr::RM::DataTypes::Basic::DataValue
    31           def initialize(value)
    32             self.value = value
     33        class DvUri < OpenEHR::RM::DataTypes::Basic::DataValue
     34          def initialize(args = {})
     35            self.value = args[:value]
    3336          end
     37
     38          def value
     39            @value.to_s
     40          end
     41
    3442          def fragment_id
    3543            @value.fragment
    3644          end
     45
    3746          def path
    3847            @value.path
    3948          end
     49
    4050          def query
    4151            @value.query
    4252          end
     53
    4354          def scheme
    4455            @value.scheme
    4556          end
     57
    4658          def value=(value)
    4759            raise ArgumentError, "value is empty" if value.nil?
    4860            parse(value)
    4961          end
    50           def value
    51             @value.to_s
    52           end
     62
    5363          private
     64
    5465          def parse(value)
    5566            @value = ::URI.parse(value)
    … …  
    6172            super(value)
    6273          end
     74
    6375          def value=(value)
    6476            raise ArgumentError, "scheme must be ehr" if !(value =~ /^ehr/i)
    65             parse(value)
     77            @value = parse(value)
    6678          end
    6779        end # of DV_EHR_URI
Note: See TracChangeset for help on using the changeset viewer.