Index: ruby/trunk/lib/open_ehr/rm.rb
===================================================================
--- ruby/trunk/lib/open_ehr/rm.rb	(revision 297)
+++ 	(revision )
@@ -1,53 +1,0 @@
-$:.unshift File.join(File.dirname(__FILE__))
-# component: openEHR Ruby reference implementation
-# description: This file contains rm.packages.domain classes
-# keywords: archetype
-# author: Shinji KOBAYASHI, Akimichi TATSUKAWA
-# support: openEHR.jp
-# license: openEHR open source license
-#
-
-# OpenEHR::RM
-module OpenEHR
-
-  autoload :Assumed_Library_Types, "assumed_library_types.rb"
-
-  module RM
-    autoload :Demographic, "rm/demographic.rb"
-    autoload :Security, "rm/security.rb"
-
-    module Common
-      autoload :Resource, "rm/common/resource.rb"
-      autoload :Archetyped, "rm/common/archetyped.rb"
-      autoload :Generic, "rm/common/generic.rb"
-      autoload :Directory, "rm/common/directory.rb"
-      autoload :Change_Control, "rm/common/change_control.rb"
-    end
-
-    module Support
-      autoload :Definition, "rm/support/definition.rb"
-      autoload :Identification, "rm/support/identification.rb"
-      autoload :Terminology, "rm/support/terminology.rb"
-    end
-
-    module DataTypes
-      autoload :Basic, "rm/data_types/basic.rb"
-      autoload :Text, "rm/data_types/text.rb"
-      autoload :URI, "rm/data_types/uri.rb"
-      autoload :Quantity, "rm/data_types/quantity.rb"
-      autoload :Encapsulated, "rm/data_types/encapsulated.rb"
-      autoload :Time_Specification, 'rm/data_types/time_specification.rb'
-    end
-
-    module DataStructures
-      autoload :Data_Structure, "rm/data_structure.rb"
-      autoload :History, 'rm/data_structures/history.rb'
-      autoload :Item_Structure, 'rm/data_structures/item_structure.rb'
-    end
-
-    module Security
-      autoload :Security, 'rm/security.rb'
-    end
-  end
-
-end
Index: ruby/trunk/lib/open_ehr/rm/data_types/quantity.rb
===================================================================
--- ruby/trunk/lib/open_ehr/rm/data_types/quantity.rb	(revision 297)
+++ ruby/trunk/lib/open_ehr/rm/data_types/quantity.rb	(revision 298)
@@ -2,21 +2,18 @@
 # http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109599337877_94556_1510Report.html
 # Ticket refs #50
-require 'assumed_library_types'
+#require 'assumed_library_types'
 module OpenEHR
   module RM
     module DataTypes
       module Quantity
-
-        autoload :Date_Time, "rm/data_types/quantity/date_time.rb"
-
         class DvOrdered < OpenEHR::RM::DataTypes::Basic::DataValue
           include Comparable
           attr_accessor :normal_range, :other_refference_ranges, :normal_status
 
-          def initialize(normal_range=nil, normal_status = nil,
-                         other_reference_ranges=nil)
-            self.normal_range = normal_range
-            self.normal_status = normal_status
-            self.other_reference_ranges = other_reference_ranges
+          def initialize(args = {})
+            super(args)
+            self.normal_range = args[:normal_range]
+            self.normal_status = args[:normal_status]
+            self.other_reference_ranges = args[:other_reference_ranges]
           end          
 
@@ -32,5 +29,5 @@
 
           def is_simple?
-            normal_status.nil? and other_refference_ranges.nil?
+            return @other_reference_ranges.nil?
           end
 
@@ -40,5 +37,5 @@
 
           def other_reference_ranges=(other_reference_ranges)
-            unless other_reference_ranges.nil? or !other_reference_ranges.is_empty?
+            if !other_reference_ranges.nil? && other_reference_ranges.empty?
               raise ArgumentError, "Other reference ranges validity error"
             end
@@ -46,6 +43,10 @@
           end
 
-          def is_strictly_comparable_to?(other)
-            raise NotImplementedError, 'this method should be implemented'
+          def is_strictly_comparable_to?(others)
+            if others.instance_of? self.class
+              return true
+            else
+              return false
+            end
           end
         end
@@ -58,14 +59,12 @@
           attr_reader :magnitude, :magnitude_status
 
-          def initialize(magnitude, magnitude_status=nil,
-                         normal_range=nil, normal_status = nil,
-                         other_reference_ranges=nil)
-            super(normal_range, normal_status, other_reference_ranges)
-            self.magnitude = magnitude
-            self.magnitude_status = magnitude_status
+          def initialize(args = {})
+            super(args)
+            self.magnitude = args[:magnitude]
+            self.magnitude_status = args[:magnitude_status]
           end
 
           def <=>(others)
-            @value <=> others.value
+            @magnitude <=> others.magnitude
           end
 
@@ -102,10 +101,8 @@
           attr_reader :value, :symbol, :limits
 
-          def initialize(value, symbol, limits=nil, normal_range=nil,
-                         normal_status = nil, other_reference_ranges=nil)
-            self.value = value
-            self.symbol = symbol
-            self.limits = limits
-            super(normal_range, normal_status, other_reference_ranges)
+          def initialize(args = {})
+            super(args)
+            self.symbol = args[:symbol]
+            self.limits = args[:limits]
           end
 
@@ -120,15 +117,4 @@
           end
 
-          def is_strictly_comparable_to?(others)
-            unless others.instance_of? OpenEhr::RM::DataTypes::Quantity::DvOrdinal
-              return false
-            end
-            unless others.symbol.defining_code.terminology_id.value ==
-                @symbol.defining_code.terminology_id.value
-              return false
-            end
-            return true
-          end
-
           def <=>(other)
             @value <=> other.value
@@ -142,4 +128,15 @@
             end
           end
+          def is_strictly_comparable_to?(others)
+            unless super(others)
+              return false
+            end
+            unless others.symbol.defining_code.terminology_id.value ==
+                @symbol.defining_code.terminology_id.value
+              return false
+            else
+              return true
+            end
+          end
         end
 
@@ -147,22 +144,41 @@
           attr_accessor :accuracy
 
-          def initialize(magnitude, magnitude_status=nil, accuracy=nil,
-                         normal_range=nil, normal_status = nil,
-                         other_reference_ranges=nil)
-            super(magnitude, magnitude_status, normal_range,
-                   normal_status, other_reference_ranges)
-            self.accuracy = accuracy
+          def initialize(args = {})
+            super(args)
+            self.accuracy = args[:accuracy]
           end
 
           def add(a_diff)
-            raise NotImplementedError, 'add must be implemented'
+            type_check(a_diff)
+            return result_builder(DvAbsoluteQuantity,
+                                  @magnitude+a_diff.magnitude)
           end
 
           def diff(other)
-            raise NotImplementedError, 'diff must be implemented'
+            type_check(other)
+            return result_builder(DvAmount,
+                                  (@magnitude-other.magnitude).abs)
           end
 
           def subtract(a_diff)
-            raise NotImplementedError, 'subtract must be implemented'
+            type_check(a_diff)
+            return result_builder(DvAbsoluteQuantity,
+                                  @magnitude-a_diff.magnitude)
+          end
+          private
+          def type_check(other)
+            unless self.is_strictly_comparable_to? other
+              raise ArgumentError, 'type mismatch'
+            end
+          end
+
+          def result_builder(klass, magnitude)
+            return klass.new(:magnitude => magnitude,
+                             :magnitude_status => @magnitude_status,
+                             :accuracy => @accuracy,
+                             :accuracy_percent => @accuracy_percent,
+                             :normal_range => @normal_range,
+                             :normal_status => @normal_status,
+                             :other_reference_ranges => @other_reference_ranges)
           end
         end
@@ -170,11 +186,9 @@
         class DvAmount < DvQuantified
           attr_reader :accuracy, :accuracy_percent
-          def initialize(magnitude, magnitude_status=nil, accuracy=nil,
-                         accuracy_percent=nil, normal_range=nil,
-                         normal_status = nil, other_reference_ranges=nil)
-            super(magnitude, magnitude_status, normal_range,
-                  normal_status, other_reference_ranges)
-            unless accuracy.nil?
-              set_accuracy(accuracy, accuracy_percent)
+
+          def initialize(args = {})
+            super(args)
+            unless args[:accuracy].nil?
+              set_accuracy(args[:accuracy], args[:accuracy_percent])
             else
               @accuracy, @accuracy_percent = nil, nil
@@ -183,13 +197,13 @@
 
           def +(other)
-            unless self.is_strictly_comparable_to?(other)
+            unless self.is_strictly_comparable_to? other
               raise ArgumentError, 'type mismatch'
             end
-            return DvAmount.new(@magnitude+other.magnitude, @magnitude_status,
-                                 @accuracy, @accuracy_percent, @normal_range,
-                                 @normal_status, @other_reference_ranges)
-          end
-
-          def -(other)
+            result = self.dup
+            result.magnitude = @magnitude + other.magnitude
+            return result
+          end
+
+          def -(other)            
             other.magnitude = - other.magnitude
             self+(other)
@@ -212,11 +226,9 @@
         class DvQuantity < DvAmount
           attr_reader :units, :precision
-          def initialize(magnitude, units, magnitude_status=nil, precision=nil,
-                         accuracy=nil, accuracy_percent=nil, normal_range=nil,
-                         normal_status = nil, other_reference_ranges=nil)
-            super(magnitude, magnitude_status, accuracy, accuracy_percent,
-                  normal_range, normal_status, other_reference_ranges)
-            self.units = units
-            self.precision = precision
+
+          def initialize(args = {})
+            super(args)
+            self.units = args[:units]
+            self.precision = args[:precision]
           end
 
@@ -234,6 +246,8 @@
 
           def is_strictly_comparable_to?(others)
-            return false if others.nil?
-            if others.instance_of?(DvQuantity) && others.units == @units
+            unless super(others)
+              return false
+            end
+            if others.units == @units
               return true
             else
@@ -249,23 +263,8 @@
             end
           end
-# accuracy???
-          def +(other)
-            dv_amount = super(other)
-            return DvQuantity.new(dv_amount.magnitude, @units,
-                                   @magnitude_status, @precision,
-                                   @accuracy, @accuracy_percent, @normal_range,
-                                   @normal_status, @other_reference_ranges)
-          end
         end
 
         class DvCount < DvAmount
-          def is_strictly_comparable_to?(others)
-            return false if others.nil?
-            if others.instance_of?(DvCount)
-              return true
-            else
-              return false
-            end
-          end
+
         end
 
@@ -273,7 +272,7 @@
           attr_reader :meaning, :range
 
-          def initialize(meaning, range)
-            self.meaning = meaning
-            self.range = range
+          def initialize(args = {})
+            self.meaning = args[:meaning]
+            self.range = args[:range]
           end
 
@@ -314,21 +313,18 @@
           attr_reader :numerator, :denominator, :type, :precision
 
-          def initialize(numerator, denominator, type, precision=nil,
-                         magnitude_status=nil, accuracy=nil,
-                         accuracy_percent=nil, normal_range=nil,
-                         normal_status = nil, other_reference_ranges=nil)
-            self.type = type
-            self.numerator = numerator
-            self.denominator = denominator
-            self.precision = precision
-            self.magnitude_status = magnitude_status
-            unless accuracy.nil?
-              set_accuracy(accuracy, accuracy_percent)
+          def initialize(args = {})
+            self.type = args[:type]
+            self.numerator = args[:numerator]
+            self.denominator = args[:denominator]
+            self.precision = args[:precision]
+            self.magnitude_status =args[:magnitude_status]
+            unless args[:accuracy].nil?
+              set_accuracy(args[:accuracy], args[:accuracy_percent])
             else
               @accuracy, @accuracy_percent = nil, nil
             end
-            self.normal_range = normal_range
-            self.normal_status = normal_status
-            self.other_reference_ranges = other_reference_ranges
+            self.normal_range = args[:normal_range]
+            self.normal_status = args[:normal_status]
+            self.other_reference_ranges = args[:other_reference_ranges]
           end
 
@@ -343,16 +339,17 @@
 
           def denominator=(denominator)
-            if denominator.nil? or denominator == PK_RATIO
-              raise ArgumentError, 'denominator invalid'
-            end
-            if (@type == PK_FRACTION || @type == PK_INTEGER_FRACTION) &&
-                !denominator.integer?
-              raise ArgumentError, 'denominator invalid for type'
-            end
-            if @type == PK_UNITARY && denominator != 1
-              raise ArgumentError, 'denominator invalid for type'
-            end
-            if @type == PK_PERCENT && denominator != 100
-              raise ArgumentError, 'denominator invaild for type'
+            case @type
+            when PK_UNITARY
+              unless denominator == 1
+                raise ArgumentError, 'Unitary denominator must be 1'
+              end
+            when PK_PERCENT
+              unless denominator == 100
+                raise ArgumentError, 'Percent denominator must be 100'
+              end
+            when PK_FRACTION, PK_INTEGER_FRACTION
+              unless denominator.integer? and @numerator.integer?
+                raise ArgumentError, 'Fraction numerator/denominator must be integer'
+              end
             end
             @denominator = denominator
@@ -373,10 +370,9 @@
           def precision=(precision)
             unless precision.nil?
-              unless precision == 0 || self.is_integral?
-                @precision = precision
-              else
+              if (self.is_integral? && precision !=0)
                 raise ArgumentError, 'precision invalid'
               end
             end
+            @precision = precision
           end
 
@@ -386,5 +382,5 @@
 
           def is_strictly_comparable_to?(other)
-            unless other.instance_of?(DvProportion)
+            unless super(other)
               return false
             end
Index: ruby/trunk/lib/open_ehr/rm/data_types/text.rb
===================================================================
--- ruby/trunk/lib/open_ehr/rm/data_types/text.rb	(revision 297)
+++ ruby/trunk/lib/open_ehr/rm/data_types/text.rb	(revision 298)
@@ -2,4 +2,6 @@
 # http://www.openehr.org/uml/release-1.0.1/Browsable/_9_0_76d0249_1109067605961_209522_3179Report.html
 # Ticket refs #48
+include OpenEHR::RM::DataTypes::Basic
+
 module OpenEHR
   module RM
@@ -8,37 +10,49 @@
         class TermMapping
           attr_reader :match, :purpose, :target
-          def initialize(match, purpose, target)
-            match_valid(match)
-            purpose_valid(purpose)
-            target_valid(target)
-            @match, @purpose, @target = match, purpose, target
+
+          def initialize(args ={})
+            self.match = args[:match]
+            self.purpose = args[:purpose]
+            self.target = args[:target]
           end
+
+          def match=(match)
+            unless TermMapping.is_valid_mach_code? match
+              raise ArgumentError, 'invalid match character'
+            end
+            @match = match
+          end
+
+          def purpose=(purpose)
+#            if !purpose.nil? and !purpose.instance_of?(DvCodedText)
+#              raise ArgumentError, "purpose is not valid"
+#            end
+            # should be settled after terminology service implemented
+            @purpose = purpose
+          end
+
+          def target=(target)
+            raise ArgumentError, "target must not be nil" if target.nil?
+            @target = target
+          end
+
           def broader?
             match == '>'
           end
+
           def equivalent?
             match == '='
           end
+
           def narrower?
             match == '<'
           end
+
           def unknown?
             match == '?'
           end
+
           def TermMapping.is_valid_mach_code?(c)
             c == '>' or c == '=' or c == '<' or c == '?'
-          end
-          private
-          def match_valid(match)
-            raise ArgumentError, "match is not valid" if !TermMapping.is_valid_mach_code? match
-          end
-          def purpose_valid(purpose)
-            if purpose.nil? or !purpose.instance_of? DvCodedText
-              raise ArgumentError, "purpose is not valid"
-            end
-            # should be settled after terminology service implemented
-          end
-          def target_valid(target)
-            raise ArgumentError, "target must not be nil" if target.nil?
           end
         end
@@ -46,16 +60,21 @@
         class CodePhrase
           attr_reader :terminology_id, :code_string
-          def initialize(code_string, terminology_id)
-            self.code_string = code_string
-            self.terminology_id = terminology_id
+
+          def initialize(args = {})
+            self.code_string = args[:code_string]
+            self.terminology_id = args[:terminology_id]
           end
 
           def terminology_id=(terminology_id)
-            raise ArgumentError, "terminology_id should not be nil" if terminology_id.nil?
+            if terminology_id.nil?
+              raise ArgumentError, "terminology_id should not be nil"
+            end
             @terminology_id = terminology_id
           end
 
           def code_string=(code_string)
-            raise ArgumentError, "code_string should not be empty" if code_string.nil? or code_string.empty?
+            if code_string.nil? or code_string.empty?
+              raise ArgumentError, "code_string should not be empty"
+            end
             @code_string = code_string
           end 
@@ -63,67 +82,52 @@
 
         class DvText < OpenEHR::RM::DataTypes::Basic::DataValue
-          attr_reader :value, :formatting, :hyperlink, :mappings
-          attr_reader :language, :encoding
-          def initialize(value, formatting = nil, hyperlink = nil,
-                         mappings = nil, language = nil, encoding = nil)
-            value_valid(value)
-            DvText.formatting_valid(formatting)
-            DvText.encoding_valid(encoding)
-            DvText.mapping_valid(mappings)
-            DvText.language_valid(language)
-            @value, @formatting, @encoding = value, formatting, encoding
-            @mappings, @language = mappings, language
+          attr_reader :formatting, :hyperlink, :mappings,
+                      :language, :encoding
+
+          def initialize(args = {})
+            super(args)
+            self.formatting = args[:formatting]
+            self.encoding = args[:encoding]
+            self.mappings = args[:mappings]
+            self.language = args[:language]
           end
+
           def value=(value)
-            value_valid(value)
+            if value.nil? or value.empty? or 
+                value.include? CR or value.include? LF
+              raise ArgumentError, "value is not valid"
+              # CR and LF are defined in Basic_Definition inherited DataValue.
+            end
             @value = value
           end
+
           def formatting=(formatting)
-            DvText.formatting_valid(formatting)
+            if !formatting.nil? and formatting.empty?
+              raise ArgumentError, "formatting is not valid"
+            end
             @formatting = formatting
           end
+
           def encoding=(encoding)
-            DvText.encoding_valid(encoding)
+            if !encoding.nil? and encoding.code_string.empty?
+              raise ArgumentError, "encoding is not valid"
+            end
             @encoding = encoding
           end
           def mappings=(mappings)
-            DvText.mapping_valid(mappings)
+            if !mappings.nil? and !mappings.instance_of? Set
+              raise ArgumentError, "mapping(s) is(are) not valid"
+            elsif !mappings.nil? and mappings.instance_of? Set and
+                mappings.empty?
+              raise ArgumentError, "mapping(s) is(are) not valid"
+            end
             @mappings = mappings
           end
           def language=(language)
-            DvText.language_valid(language)
+            if !@language.nil? and language.empty?
+              raise ArgumentError, "langage is not valid"
+            end
             @language = language
           end
-          private
-          def value_valid(value)
-            if value.nil? or value.empty? or value.include? CR or value.include? LF
-              raise ArgumentError, "value is not valid"
-              # CR and LF are defined in Basic_Definition inherited DataValue.
-            end
-          end
-
-          class << self
-
-            def formatting_valid(formatting)
-              raise ArgumentError, "formatting is not valid" if formatting != nil and formatting.empty?
-            end
-
-            def encoding_valid(encoding)
-              raise ArgumentError, "encoding is not valid" if encoding != nil and encoding.empty?
-            end
-
-            def mapping_valid(mapping)
-              if !mapping.nil? and !mapping.instance_of? Set
-                raise ArgumentError, "mapping(s) is(are) not valid"
-              elsif !mapping.nil? and mapping.instance_of? Set
-                raise ArgumentError, "mapping(s) is(are) not valid" if mapping.empty? 
-              end
-            end
-
-            def language_valid(language)
-              raise ArgumentError, "langage is not valid" if language != nil and language.empty?
-            end
-          end
-
         end
 
@@ -131,14 +135,12 @@
           attr_reader :defining_code
 
-          def initialize(value, defining_code, formatting = nil, 
-                         hyperlink = nil, mappings = nil, language = nil, 
-                         encoding = nil)
-            super(value, formatting, hyperlink, mappings, language, encoding)
-            self.defining_code = defining_code
+          def initialize(args = {})
+            super(args)
+            self.defining_code = args[:defining_code]
           end
 
           def defining_code=(defining_code)
             if defining_code.nil?
-              raise ArgumentError, "Defiinition must be exist" 
+              raise ArgumentError, 'defiining code is mandatory'
             end
             @defining_code = defining_code
@@ -148,19 +150,14 @@
         class DvParagraph < OpenEHR::RM::DataTypes::Basic::DataValue
           attr_reader :items
-          def initialize(items)
-            items_exists(items)
+
+          def initialize(args ={})
+            self.items = args[:items]
+          end
+
+          def items=(items)
+            if items.nil? or items.empty?
+              raise ArgumentError, "Items are not valid"
+            end
             @items = items
-          end
-          def items=(items)
-            items_exists(items)
-            @items = items
-          end
-          private
-          def items_exists(items)
-            if !items.nil? and !items.instance_of? Set
-              raise ArgumentError, "Items are not valid"
-            elsif !items.nil? and items.instance_of? Set
-              raise ArgumentError, "Items must be exist" if items.empty?
-            end
           end
         end
Index: ruby/trunk/lib/open_ehr/rm/support/terminology.rb
===================================================================
--- ruby/trunk/lib/open_ehr/rm/support/terminology.rb	(revision 297)
+++ ruby/trunk/lib/open_ehr/rm/support/terminology.rb	(revision 298)
@@ -1,4 +1,4 @@
 
-module OpenEhr
+module OpenEHR
   module RM
     module Support
@@ -8,15 +8,19 @@
             raise NotImplementedError, "all_codes must be implemented"
           end
+
           def has_code(a_code)
             raise NotImplementedError, "has_code must be implemented"
           end
+
           def has_lang(a_lang)
             raise NotImplementedError, "has_lang must be implemented"
           end
+
           def id
             raise NotImplementedError, "id must be returned"
           end
         end
-        module OpenEhrCodeSetIdentifier
+
+        module OpenEHRCodeSetIdentifier
           CODE_SET_ID_CHARACER_SETS = "character sets".freeze
           CODE_SET_ID_COMPRESSION_ALGORITHMS = "compression algorithms".freeze
@@ -29,5 +33,6 @@
           end
         end
-        module OpenEhrTerminologyGroupIdentifiers
+
+        module OpenEHRTerminologyGroupIdentifiers
           GROUP_ID_ATTESTATION_REASON = "attestation reason".freeze
           GROUP_ID_AUDIT_CHANGE_TYPE = "audit change type".freeze
@@ -46,23 +51,38 @@
           TERMINOLOGY_ID = "openehr".freeze
         end
+
         class TerminologyAccess
+          attr_reader :id
+
+          def initialize(args = {})
+            self.id = args[:id]
+          end
+
           def all_codes
             raise NotImplementedError, "all_codes is not implemented"
           end
+
           def codes_for_group_id(group_id)
             raise NotImplementedError, "codes_for_group_id is not implemented"
           end
+
           def codes_for_group_name(name, lang)
             raise NotImplementedError, "codes_for_group_name is not implemented"
           end
+
           def has_code_for_group_id(group_id, a_code)
-            raise NotImplementedError, "has_code_for_group_id is not implemented"
+            
           end
-          def id
-            raise NotImplementedError, "id is not implemented"
+
+          def id=(id)
+            @terminology = Terminology.find_all_by_name(id)
+            @id = id
           end
+
           def rubric_for_code(code, lang)
-            raise NotImplementedError, "rubic_for_code is not implemented"
+            return Terminology.find(:first, :conditions => {:code => code,
+                                      :lang => lang})
           end
+
           private
           def id_exists
@@ -74,27 +94,36 @@
           end
         end
+
         class TerminologyService
-          include OpenEhrCodeSetIdentifier, OpenEhrTerminologyGroupIdentifiers
+          include OpenEHRCodeSetIdentifier, OpenEHRTerminologyGroupIdentifiers
+
           def code_set(name)
             raise NotImplementedError, "code_set is not implemented"
           end
+
           def code_set_for_id(id)
             raise NotImplementedError, "code_set_for_id is not implemented"
           end
+
           def code_set_identifiers
             raise NotImplementedError, "code_set_for_identifiers is not implemented"
           end
+
           def has_code_set(name)
             raise NotImplementedError, "has_code_set is not implemented"
           end
+
           def has_terminology?(name)
             raise NotImplementedError, "has_terminology is not implemented"
           end
+
           def openehr_code_sets
             raise NotImplementedError, "openehr_code_set is not implemented"
           end
+
           def terminology(name)
-            raise NotImplementedError, "terminology is not implemented"
+            return TerminologyAccess.new(:id => name)
           end
+          
           def terminology_identifiers
             raise NotImplementedError, "terminology_identiferes is not implemented"
