Changeset 23 for ruby/trunk/models/am/archetype

Timestamp:

May 1, 2008, 8:21:09 AM (16 years ago)

Author:

Tatsukawa, Akimichi

Message:

working on adl_parser semantic functions

Location:

ruby/trunk/models/am/archetype

Files:

• archetype.rb (modified) (1 diff)
• archetype_description/archetype_description.rb (modified) (1 diff)
• constraint_model/archetype_constraint.rb (modified) (3 diffs)
• constraint_model/assertion.rb (modified) (1 diff)
• constraint_model/primitive.rb (modified) (3 diffs)
• ontology.rb (modified) (1 diff)

ruby/trunk/models/am/archetype/archetype.rb

@@ -77 +77 @@
         def version
         end
-      end
+      end # end of ARCHETYPE
       # original file:
       # ref_imple_eiffel/components/adl_parser/src/interface/adl_definition.e
-    end # end of Archetype
+
+      class VALIDITY_KIND
+      end
+    end
+
+
   end # end of AM
 end # end of OpenEHR

ruby/trunk/models/am/archetype/archetype_description/archetype_description.rb

@@ -11 +11 @@
         end
 
-        class Archetype_Description_Item
+        class ARCHETYPE_DESCRIPTION_ITEM
           attr_accessor :archetype_package_uri, :lifecycle_state, :original_author, :other_contributors, :other_details
         end

ruby/trunk/models/am/archetype/constraint_model/archetype_constraint.rb

@@ -8 +8 @@
         end
 
-        class C_OBJECT < ARCHETYPE_CONSTRAINT
+        class CARDINALITY
           
         end
 
+        class C_OBJECT < ARCHETYPE_CONSTRAINT
+          attr_accessor :node_id, :occurrences, :rm_type_name
+
+          def initialize(args = { })
+            @node_id = args[:node_id] if args[:node_id]
+            @occurrences = args[:occurrences] if args[:occurrences]
+            @rm_type_name = args[:rm_type_name] if args[:rm_type_name]
+          end
+        end
+
         class C_ATTRIBUTE < ARCHETYPE_CONSTRAINT
-          
+          attr_accessor :rm_attribute_name, :existence, :children
+
+          def initialize(args = { })
+            @rm_attribute_name = args[:rm_attribute_name] if args[:rm_attribute_name]
+            @existence = args[:existence] if args[:existence]
+            @children = args[:children] ? args[:children] : []
+            
+          end
         end
 
         class C_DEFINED_OBJECT < C_OBJECT
+          attr_accessor :assumed_value
           
+          def initialize(args = { })
+            @assumed_value = args[:assumed_value] if args[:assumed_value]
+            super
+          end
         end
 
         class C_PRIMITIVE_OBJECT < C_DEFINED_OBJECT
+          attr_accessor :item
           
+          def initialize(args = { })
+            @attributes = args[:item] if args[:item]
+            super
+          end
         end
 
@@ -27 +54 @@
           attr_accessor :attributes, :attributes_valid
           
+          def initialize(args = { })
+            @attributes = args[:attributes] ? args[:attributes] : []
+            super
+          end
+
+          def self.create(args = { }, &block)
+            c_complex_object = new(args)
+            if block_given?
+              yield c_complex_object
+            end
+            return c_complex_object
+          end
         end
 
@@ -49 +88 @@
         end
 
+        class C_SINGLE_ATTRIBUTE < C_ATTRIBUTE
+          attr_accessor :alternatives
+
+          def initialize(args = { })
+            @alternatives = args[:alternatives] ? args[:alternatives] : []
+            super
+          end
+        end
+
+        class C_MULTIPLE_ATTRIBUTE < C_ATTRIBUTE
+          attr_accessor :members, :cardinality
+          
+          def initialize(args = { })
+            @members = args[:members] ? args[:members] : []
+            @cardinality = args[:cardinality] if args[:cardinality]
+            super
+          end
+        end
       end
     end

ruby/trunk/models/am/archetype/constraint_model/assertion.rb

@@ -2 +2 @@
   module AM
     module Archetype
-      module Constraint_Model
-        module Assertion
-          class Assertion
-          end
+      module Assertion
+        class ASSERTION
+        end
+
+        class ASSERTION_VARIABLE
+        end
+
+        class OPERATOR_KIND
+        end
+
+        class EXPR_ITEM
+        end
+
+        class EXPR_LEAF < EXPR_ITEM
+        end
+
+        class EXPR_OPERATOR < EXPR_ITEM
+        end
+
+        class EXPR_UNARY_OPERATOR < EXPR_OPERATOR
+        end
+
+        class EXPR_BINARY_OPERATOR < EXPR_OPERATOR
         end
       end

ruby/trunk/models/am/archetype/constraint_model/primitive.rb

@@ -6 +6 @@
         module Primitive
 
-          class C_Primitive
+          class C_PRIMITIVE
             def assumed_value
               raise NotImplementedError, "assumed_value should be implemented"
@@ -21 +21 @@
           end
 
-          class C_Boolean < C_Primitive
-            attr_accessor :assumed_value
-            def initialize(true_valid, false_valid, assumed_value)
-              binary_consistency(true_valid, false_valid)
-              @true_valid = true_valid
-              @false_valid = false_valid
-              @assumed_value = assumed_value
+          class C_BOOLEAN < C_PRIMITIVE
+            attr_reader :true_valid, :false_valid, :assumed_value
+
+            def initialize(args = { })
+              @true_valid = args[:true_valid] ? args[:true_valid] : false
+              @false_valid = args[:false_valid] ? args[:false_valid] : false
+              @assumed_value = args[:assumed_value] ? args[:assumed_value] : false
+              binary_consistency(@true_valid, @false_valid)
             end
-            def set_true_valid(true_valid)
+
+            def true_valid=(true_valid)
               binary_consistency(true_valid, @false_valid)
               @true_valid = true_valid
             end
-            def set_false_valid(false_valid)
+
+            def false_valid=(false_valid)
               binary_consistency(@true_valid,false_valid)
               @false_valid = false_valid 
             end
-            def true_valid?
-              @true_valid
-            end
-            def false_valid?
-              @false_valid
-            end
+
             def valid_value?
               
             end
-            def default_value(a_value=nil)
+
+            def default_value(a_value = nil)
               if a_value == nil
                 @true_valid
@@ -63 +62 @@
           end # of C_Boolean
 
-          class C_Integer < C_Primitive
+          class C_STRING < C_PRIMITIVE
             
           end
+
+          class C_INTEGER < C_PRIMITIVE
+            
+          end
+
+          class C_REAL < C_PRIMITIVE
+            
+          end
+
+          class C_TIME < C_PRIMITIVE
+            
+          end
+
+          class C_DATE < C_PRIMITIVE
+            
+          end
+
+          class C_DATE_TIME < C_PRIMITIVE
+            
+          end
+
+          class C_DURATION < C_PRIMITIVE
+            
+          end
+
+
+
         end # of Primitive
       end # of Constraint_Model

ruby/trunk/models/am/archetype/ontology.rb

@@ -3 +3 @@
     module Archetype
       module Ontology
-        class Archetype_Ontology
+        class ARCHETYPE_ONTOLOGY
           attr_accessor :constraint_codes, :specialisation_depth
           attr_accessor :term_attribute_names, :term_codes
           attr_accessor :terminologies_available
+
           def constraint_binding(a_terminology, a_code)
           end
+
           def constraint_definition(a_lang, a_code)
           end
+
           def has_language?(a_lang)
           end
+
           def has_terminology?(a_terminology)
           end
+
           def term_binding(a_terminology, a_code)
           end
+
           def term_definition(a_lang, a_code)
           end
         end
-        class Archetype_Term
+
+        class ARCHETYPE_TERM
           attr_accessor :code, :items
-          def initialize(code, items)
-            if code == nil
-              raise ArgumentError, "Code is empty"
-            end
-            if items.keys == nil
-              raise ArgumentError, "Items is empty"
-            end
-            @code = code
-            @items = items
+
+          def initialize(args = { })
+                         
+            @code = if args[:code]
+                      args[:code]
+                    else
+                      raise ArgumentError, "Code is empty"
+                    end
+            @items = if args[:items]
+                       args[:items]
+                     else
+                       raise ArgumentError, "Items is empty"
+                     end
           end
+
           def keys
-            items.keys
+            @items.keys
           end
         end