source: ruby/branches/0.5/lib/open_ehr/rm/support/identification.rb @ 262

Last change on this file since 262 was 262, checked in by KOBAYASHI, Shinji, 11 years ago

archetype id corrected

File size: 10.7 KB
Line 
1# This module is an implementation of this UML:
2# http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109331021343_528780_2066Report.html
3# Ticket refs #39
4module OpenEHR
5  module RM
6    module Support
7      module Identification
8        class ObjectID
9          attr_reader :value
10
11          def initialize(args = {})
12            self.value=args[:value]
13          end
14
15          def value=(value)
16            raise ArgumentError, "empty value" if value.nil? or value.empty?
17            @value = value           
18          end
19
20          def ==(object_id)
21            @value == object_id.value
22          end
23        end # of ObjectID
24
25        class ObjectRef
26          attr_reader :namespace, :type, :id
27
28          def initialize(namespace, type, id)
29            self.namespace = namespace
30            self.type = type
31            self.id = id
32          end
33
34          def namespace=(namespace)
35            raise ArgumentError if namespace.nil? or namespace.empty? or !(/([a-z]|[A-Z]).*/ =~ namespace) # error original is =~ #([a-z][A-Z])([a-z]|[A-Z]|\s|[v0-9]|[_-\:\/\&\+\?])*/
36            @namespace = namespace
37          end
38
39          def type=(type)
40            raise ArgumentError if type.nil? or type.empty?
41            @type = type
42          end
43
44          def id=(id)
45            raise ArgumentError if id.nil?
46            @id = id
47          end
48        end
49
50        class ArchetypeID < ObjectID
51          attr_reader :rm_originator, :rm_name, :rm_entity,
52                      :concept_name, :specialisation, :version_id
53         
54          def initialize(args = {})
55            super(args)
56            if args[:value].nil?
57              self.rm_originator = args[:rm_originator]
58              self.rm_name = args[:rm_name]
59              self.rm_entity = args[:rm_entity]
60              self.concept_name = args[:concept_name]
61              self.version_id = args[:version_id]
62              self.specialisation = args[:specialisation]
63            else
64              self.value = args[:value]
65            end
66          end
67
68          def value=(value)
69            if /([a-zA-Z]\w+)-([a-zA-Z]\w+)-([a-zA-Z]\w+)\.([a-zA-Z]\w+)(-([a-zA-Z]\w+))?\.(v[1-9]\d*)/ =~ value
70              self.rm_originator = $1
71              self.rm_name = $2
72              self.rm_entity = $3
73              self.concept_name = $4
74              self.specialisation = $6
75              self.version_id = $7
76            else
77              raise ArgumentError, 'invalid archetype id form'
78            end
79          end
80
81          def qualified_rm_entity
82            return @rm_originator + '-' + @rm_name + '-' + @rm_entity
83          end
84
85          def domain_concept
86            return @concept_name + '-' + @specialisation
87          end
88
89          def concept_name=(concept_name)
90            if concept_name.nil? or concept_name.empty?
91              raise ArgumentError, 'concept_name is mandatory'
92            end
93            @concept_name = concept_name
94          end
95
96          def domain_concept=(domain_concept)
97            if domain_concept.nil? or domain_concept.empty?
98              raise ArgumentError, "domain concept not valid"
99            end
100            if /([a-zA-Z]\w+)(-([a-zA-Z]\w))?/ =~ domain_concept
101              self.concept_name = $1
102              self.specialisation = $3
103            else
104              raise ArgumentError, 'invalid domain concept form'
105            end
106          end
107
108          def rm_name=(rm_name)
109            raise ArgumentError, "rm_name not valid" if rm_name.nil? or rm_name.empty?
110            @rm_name = rm_name
111          end
112
113          def rm_entity=(rm_entity)
114            if rm_entity.nil? or rm_entity.empty?
115              raise ArgumentError, "rm_entity is mandatory"
116            end
117            @rm_entity = rm_entity
118          end
119
120          def rm_originator=(rm_originator)
121            if rm_originator.nil? or rm_originator.empty?
122              raise ArgumentError, "rm_originator not valid"
123            end
124            @rm_originator = rm_originator
125          end
126
127          def specialisation=(specialisation)
128            if !specialisation.nil? and specialisation.empty?
129              raise ArgumentError, "rm_specialisation not valid" 
130            end
131            @specialisation = specialisation
132          end
133          def version_id=(version_id)
134            raise ArgumentError, "version_id not valid" if version_id.nil? or version_id.empty?
135            @version_id = version_id
136          end
137        end
138
139        class TerminologyID < ObjectID
140          attr_reader :name, :version_id
141
142          def initialize(args = {})
143            super(args)
144          end
145
146          def value
147            if @version_id.empty?
148              @name
149            else
150              @name + '(' + @version_id + ')'
151            end 
152          end
153
154
155          def value=(value)
156            raise ArgumentError, "value not valid" if value.nil? or value.empty?
157            if /(.*)\((.*)\)$/ =~ value
158              @name = $1
159              @version_id = $2
160            else
161              @name = value
162              @version_id = ''
163            end
164            @value = value
165          end
166
167          def name=(name)
168            raise ArgumentError, "name not valid" if name.nil? or name.empty?
169            @name = name
170          end
171
172          def version_id=(version_id)
173            raise ArgumentError, "version_id not valid" if version_id.nil?
174            @version_id = version_id
175          end
176        end # of Terminology_ID
177
178        class GenericID < ObjectID
179          attr_reader :scheme
180
181          def initialize(value, scheme)
182            super(value)
183            self.scheme = scheme
184          end
185
186          def scheme=(scheme)
187            raise ArgumentError, "scheme not valid" if scheme.nil? or scheme.empty?
188            @scheme = scheme
189          end
190        end # of Generic_ID
191
192        class TemplateID < ObjectID
193
194        end
195
196        class UIDBasedID < ObjectID
197          def initialize(value)
198            super(value)
199          end
200
201          def extension
202            if self.has_extension?
203              @value[/::.*/][2..-1]
204            else
205              ''
206            end
207          end
208
209          def has_extension?
210            @value.include? '::'
211          end
212
213          def root
214            if self.has_extension?
215              @value[/.*::/][0..-3]
216            else
217              @value
218            end
219          end
220        end
221
222        class ObjectVersionID < UIDBasedID
223          attr_reader :object_id, :creating_system_id, :version_tree_id
224
225          def initialize(value)
226            super(value)
227          end
228
229          def value=(value)
230            super(value)
231            if /^(\w+)::(\w+)::((\d|\.)+)$/ =~ value
232              self.object_id = UID.new($1)
233              self.creating_system_id = UID.new($2)
234              self.version_tree_id = VersionTreeID.new($3)
235            else
236              raise ArgumentError, 'invalid format'
237            end
238          end
239
240          def object_id=(object_id)
241            raise ArgumentError, 'object_id is mandatory' if object_id.nil?
242            @object_id = object_id
243          end
244
245          def creating_system_id=(creating_system_id)
246            if creating_system_id.nil?
247              raise ArgumentError, 'creating_system_id is mandatory'
248            end
249            @creating_system_id = creating_system_id
250          end
251
252          def version_tree_id=(version_tree_id)
253            if version_tree_id.nil?
254              raise ArgumentError, 'version_tree_id is mandatory'
255            end
256            @version_tree_id = version_tree_id
257          end
258
259          def is_branch?
260            return @version_tree_id.is_branch?
261          end
262        end
263
264        class LocatableRef < ObjectRef
265          attr_reader :namespace, :type, :id, :path
266
267          def initialize(namespace, type, id, path)
268            super(namespace, type, id)
269            self.path = path
270          end
271
272          def path=(path)
273            raise ArgumentError if path.nil? or path.empty?
274            @path = path
275          end
276
277          def as_uri
278            'ehr://' + @id.value + '/' + @path
279          end
280        end
281
282        class PartyRef < ObjectRef
283
284          def type=(type)
285            parties = ['PERSON', 'ORGANISATION', 'GROUP', 'AGENT', 'ROLE','PARTY', 'ACTOR']
286            raise ArgumentError, 'type invalid' unless parties.include? type
287            @type = type
288          end
289        end
290
291        class AccessGroupRef < ObjectRef
292          def type=(type)
293            raise ArgumentError, 'type invalid' unless type == 'ACCESS_GROUP'
294            @type = type
295          end
296        end
297
298        class HierObjectID < UIDBasedID
299
300        end
301
302        class VersionTreeID
303          attr_reader :value, :trunk_version, :branch_number, :branch_version
304
305          def initialize(value)
306            self.value = value
307          end
308
309          def value=(value)
310            raise ArgumentError, 'value invalid' if value.nil? or value.empty?
311            @trunk_version = @branch_number = @branch_version = nil
312            (trunk_version, branch_number, branch_version) = value.split '.'
313            self.trunk_version = trunk_version
314            self.branch_number = branch_number
315            self.branch_version = branch_version
316          end
317
318          def trunk_version=(trunk_version)
319            raise ArgumentError, 'trunk_version invalid' if trunk_version.nil? and !trunk_version.to_i >= 1
320            @trunk_version = trunk_version
321            set_value
322          end
323
324          def branch_number=(branch_number)
325            raise ArgumentError, 'branch number invalid' unless branch_number.nil? or branch_number.to_i >= 1
326            @branch_number = branch_number
327            set_value
328          end
329
330          def branch_version=(branch_version)
331            raise ArgumentError, 'branch version invalid' if (!branch_version.nil? and !( branch_version.to_i >= 1)) or (!branch_version.nil? and @branch_number.nil?)
332            @branch_version = branch_version
333            set_value
334          end
335          def is_branch?
336            !@branch_version.nil? and !@branch_number.nil?
337          end
338
339          def is_first?
340            trunk_version == '1'
341          end
342
343          private
344          def set_value
345            @value = trunk_version
346            @value = @value + '.' + @branch_number unless @branch_number.nil?
347            @value = @value + '.' + @branch_version unless @branch_version.nil?
348          end
349        end
350
351        class UID
352          attr_reader :value
353
354          def initialize(value)
355            self.value = value
356          end
357
358          def value=(value)
359            raise ArgumentError if value.nil? or value.empty?
360            @value = value
361          end
362        end
363
364        class UUID < UID
365
366        end
367
368        class InternetID <UID
369         
370        end
371
372        class IsoOID <UID
373
374        end       
375      end # of Identification
376    end # of Support
377  end # of RM
378end # of OpenEHR
Note: See TracBrowser for help on using the repository browser.