rgen 0.4.2 → 0.4.3

data/CHANGELOG

@@ -57,3 +57,10 @@
 * Performance improvement: find on environment hashes elements by class
 * Extended Transformer to allow sharing of result maps between several Transformer instances
 * Bugfix: User defined upper bound values are no longer overwritten by -1 in all "many" metamodel builder methods
+
+=0.4.3 (Aug 12th, 2008)
+
+* Performance improvement: significant speed up of metamodel reverse registration
+* Bugfix: Use object identity for metamodel to-many add/remove methods
+* Bugfix: If expand's :for expression evaluates to nil an error is generated (silently used current context before)
+* Template language indentation string can be set on DirectoryTemplateContainer and with the "file" command

data/lib/rgen/metamodel_builder.rb

@@ -184,11 +184,12 @@ module MetamodelBuilder
 		extend RGen::ECore::ECoreInstantiator
 		
 		def initialize(arg=nil)
-          arg.each_pair { |k,v| setGeneric(k, v) } if arg.is_a?(Hash)
+	    arg.each_pair { |k,v| setGeneric(k, v) } if arg.is_a?(Hash)
 		end
-    	def self.method_added(m)
-    	  raise "Do not add methods to model classes directly, add them to the ClassModule instead"
-    	end
+    
+	  def self.method_added(m)
+	    raise "Do not add methods to model classes directly, add them to the ClassModule instead"
+	  end
 	end
 	
 end

data/lib/rgen/metamodel_builder.rb.bak

@@ -0,0 +1,196 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'rgen/metamodel_builder/builder_runtime'
+require 'rgen/metamodel_builder/builder_extensions'
+require 'rgen/metamodel_builder/module_extension'
+require 'rgen/metamodel_builder/data_types'
+require 'rgen/metamodel_builder/mm_multiple'
+require 'rgen/ecore/ecore_instantiator'
+
+module RGen
+
+# MetamodelBuilder can be used to create a metamodel, i.e. Ruby classes which
+# act as metamodel elements.
+# 
+# To create a new metamodel element, create a Ruby class which inherits from
+# MetamodelBuilder::MMBase
+# 
+# 	class Person < RGen::MetamodelBuilder::MMBase
+# 	end
+# 
+# This way a couple of class methods are made available to the new class.
+# These methods can be used to:
+# * add attributes to the class
+# * add associations with other classes
+# 
+# Here is an example:
+# 
+# 	class Person < RGen::MetamodelBuilder::MMBase
+# 		has_attr 'name', String
+# 		has_attr 'age', Integer
+# 	end
+# 
+# 	class House < RGen::MetamodelBuilder::MMBase
+# 		has_attr 'address' # String is default
+# 	end
+# 
+# 	Person.many_to_many 'homes', House, 'inhabitants'
+# 
+# See BuilderExtensions for details about the available class methods.
+# 
+# =Attributes
+# 
+# The example above creates two classes 'Person' and 'House'. Person has the attributes
+# 'name' and 'age', House has the attribute 'address'. The attributes can be 
+# accessed on instances of the classes in the following way:
+# 
+# 	p = Person.new
+# 	p.name = "MyName"
+# 	p.age = 22
+# 	p.name	# => "MyName"
+# 	p.age 	# => 22
+# 
+# Note that the class Person takes care of the type of its attributes. As 
+# declared above, a 'name' can only be a String, an 'age' must be an Integer.
+# So the following would return an exception:
+# 
+# 	p.name = :myName	# => exception: can not put a Symbol where a String is expected
+# 
+# If the type of an attribute should be left undefined, use Object as type.
+#
+# =Associations
+# 
+# As well as attributes show up as instance methods, associations bring their own
+# accessor methods. For the Person-to-House association this would be:
+# 
+# 	h1 = House.new
+# 	h1.address = "Street1"
+# 	h2 = House.new
+# 	h2.address = "Street2"
+# 	p.addHomes(h1)
+# 	p.addHomes(h2)
+# 	p.removeHomes(h1)
+# 	p.homes	# => [ h2 ]
+# 
+# The Person-to-House association is _bidirectional_. This means that with the 
+# addition of a House to a Person, the Person is also added to the House. Thus:
+# 
+# 	h1.inhabitants	# => []
+# 	h2.inhabitants	# => [ p ]
+# 	
+# Note that the association is defined between two specific classes, instances of
+# different classes can not be added. Thus, the following would result in an 
+# exception:
+# 
+# 	p.addHomes(:justASymbol) # => exception: can not put a Symbol where a House is expected
+#
+# =ECore Metamodel description
+# 
+# The class methods described above are used to create a Ruby representation of the metamodel
+# we have in mind in a very simple and easy way. We don't have to care about all the details
+# of a metamodel at this point (e.g. multiplicities, changeability, etc).
+# 
+# At the same time however, an instance of the ECore metametamodel (i.e. a ECore based
+# description of our metamodel) is provided for all the Ruby classes and modules we create.
+# Since we did not provide the nitty-gritty details of the metamodel, defaults are used to
+# fully complete the ECore metamodel description.
+#
+# In order to access the ECore metamodel description, just call the +ecore+ method on a
+# Ruby class or module object belonging to your metamodel.
+# 
+# Here is the example continued from above:
+# 
+# 	Person.ecore.eAttributes.name # => ["name", "age"]
+# 	h2pRef = House.ecore.eReferences.first
+# 	h2pRef.eType                  # => Person
+# 	h2pRef.eOpposite.eType        # => House
+# 	h2pRef.lowerBound             # => 0
+# 	h2pRef.upperBound             # => -1
+# 	h2pRef.many                   # => true
+# 	h2pRef.containment            # => false
+# 
+# Note that the use of array_extensions.rb is assumed here to make model navigation convenient.
+# 
+# The following metamodel builder methods are supported, see individual method description
+# for details:
+# 
+# Attributes:
+# * BuilderExtensions#has_attr
+# 
+# Unidirectional references:
+# * BuilderExtensions#has_one
+# * BuilderExtensions#has_many
+# * BuilderExtensions#contains_one_uni
+# * BuilderExtensions#contains_many_uni
+# 
+# Bidirectional references:
+# * BuilderExtensions#one_to_one
+# * BuilderExtensions#one_to_many
+# * BuilderExtensions#many_to_one
+# * BuilderExtensions#many_to_many
+# * BuilderExtensions#contains_one
+# * BuilderExtensions#contains_many
+# 
+# Every builder command can optionally take a specification of further ECore properties.
+# Additional properties for Attributes and References are (with defaults in brackets):
+# * :ordered (true), 
+# * :unique (true),
+# * :changeable (true),
+# * :volatile (false),
+# * :transient (false),
+# * :unsettable (false),
+# * :derived (false),
+# * :lowerBound (0),
+# * :resolveProxies (true) <i>references only</i>,
+# 
+# Using these additional properties, the above example can be refined as follows:
+# 
+# 	class Person < RGen::MetamodelBuilder::MMBase
+# 		has_attr 'name', String, :lowerBound => 1
+# 		has_attr 'yearOfBirth', Integer,
+# 		has_attr 'age', Integer, :derived => true
+# 		def age_derived
+# 			Time.now.year - yearOfBirth
+# 		end
+# 	end
+# 
+# 	Person.many_to_many 'homes', House, 'inhabitants', :upperBound => 5
+# 
+# 	Person.ecore.eReferences.find{|r| r.name == 'homes'}.upperBound # => 5
+# 
+# This way we state that there must be a name for each person, we introduce a new attribute
+# 'yearOfBirth' and make 'age' a derived attribute. We also say that a person can 
+# have at most 5 houses in our metamodel.
+# 
+# ==Derived attributes and references
+# 
+# If the attribute 'derived' of an attribute or reference is set to true, a method +attributeName_derived+
+# has to be provided. This method is called whenever the original attribute is accessed. The
+# original attribute can not be written if it is derived.
+# 
+#
+module MetamodelBuilder	
+
+	# Use this class as a start for new metamodel elements (i.e. Ruby classes)
+	# by inheriting for it.
+	# 
+	# See MetamodelBuilder for an example.
+	class MMBase
+		include BuilderRuntime
+		include DataTypes
+		extend BuilderExtensions
+		extend ModuleExtension
+		extend RGen::ECore::ECoreInstantiator
+		
+		def initialize(arg=nil)
+          arg.each_pair { |k,v| setGeneric(k, v) } if arg.is_a?(Hash)
+		end
+    	def self.method_added(m)
+    	  raise "Do not add methods to model classes directly, add them to the ClassModule instead"
+    	end
+	end
+	
+end
+
+end

data/lib/rgen/metamodel_builder/builder_extensions.rb

@@ -219,18 +219,10 @@ module BuilderExtensions
 		@metamodel_description ||= []
 	end
 	
-	def inherited(c)
-	   c._class_module
+  	def inherited(c)
+    	c.send(:include, c.const_set(:ClassModule, Module.new))
 	end
 		
-	def _class_module # :nodoc:
-        unless const_defined?(:ClassModule)
-          const_set(:ClassModule, Module.new)
-          include const_get(:ClassModule)
-        end
-        const_get(:ClassModule)
-    end
-		
 	protected
 		
 	# Central builder method
@@ -282,7 +274,7 @@ module BuilderExtensions
 				alias get<%= firstToUpper(name) %> <%= name %>
 
 			CODE
-			_class_module.module_eval(@@one_read_builder.result(binding))
+			self::ClassModule.module_eval(@@one_read_builder.result(binding))
 		end
 		
 		if props.value(:changeable)
@@ -294,14 +286,22 @@ module BuilderExtensions
 					oldval = @<%= name %>
 					@<%= name %> = val
 					<% if other_role && other_kind %>
-						_unregister(self,oldval,"<%= other_role %>","<%= other_kind %>")
-						_register(self,val,"<%= other_role %>","<%= other_kind %>")
+						oldval._unregister<%= firstToUpper(other_role) %>(self) unless oldval.nil?
+						val._register<%= firstToUpper(other_role) %>(self) unless val.nil?
 					<% end %>
 				end 
 				alias set<%= firstToUpper(name) %> <%= name %>=
-				
+
+				def _register<%= firstToUpper(name) %>(val)
+					@<%= name %> = val
+				end
+        
+				def _unregister<%= firstToUpper(name) %>(val)
+					@<%= name %> = nil
+				end
+        
 			CODE
-			_class_module.module_eval(@@one_write_builder.result(binding))
+			self::ClassModule.module_eval(@@one_write_builder.result(binding))
 
 		end
 	end
@@ -324,7 +324,7 @@ module BuilderExtensions
 				alias get<%= firstToUpper(name) %> <%= name %>
 							
 			CODE
-			_class_module.module_eval(@@many_read_builder.result(binding))
+			self::ClassModule.module_eval(@@many_read_builder.result(binding))
 		end
 		
 		if props.value(:changeable)
@@ -332,41 +332,54 @@ module BuilderExtensions
 		
 				def add<%= firstToUpper(name) %>(val)
 					@<%= name %> = [] unless @<%= name %>
-					return if val.nil? or @<%= name %>.include?(val) 
+					return if val.nil? || @<%= name %>.any?{|e| e.object_id == val.object_id} 
 					<%= type_check_code("val", props) %>
 					@<%= name %>.push val
 					<% if other_role && other_kind %>
-						_register(self, val, "<%= other_role %>", "<%= other_kind %>")
+						val._register<%= firstToUpper(other_role) %>(self)
 					<% end %>
 				end
 				
 				def remove<%= firstToUpper(name) %>(val)
 					@<%= name %> = [] unless @<%= name %>
-					return unless @<%= name %>.include?(val)
-					@<%= name %>.delete val
-					<% if other_role && other_kind %>
-						_unregister(self, val, "<%= other_role %>", "<%= other_kind %>")
-					<% end %>
-				end
-				
-				def <%= name %>=(val)
-					return if val.nil?
-					raise _assignmentTypeError(self, val, Array) unless val.is_a? Array
-					getGeneric(:<%= name %>).each {|e|
-						remove<%= firstToUpper(name) %>(e)
-					}
-					val.each {|v|
-						add<%= firstToUpper(name) %>(v)
-					}
+					@<%= name %>.each_with_index do |e,i|
+						if e.object_id == val.object_id
+							@<%= name %>.delete_at(i)
+    						<% if other_role && other_kind %>
+								val._unregister<%= firstToUpper(other_role) %>(self)
+    						<% end %>
+							return
+						end
+	        		end    
 				end
+        
+        def <%= name %>=(val)
+          return if val.nil?
+          raise _assignmentTypeError(self, val, Array) unless val.is_a? Array
+          get<%= firstToUpper(name) %>.each {|e|
+            remove<%= firstToUpper(name) %>(e)
+          }
+          val.each {|v|
+            add<%= firstToUpper(name) %>(v)
+          }
+        end
 				alias set<%= firstToUpper(name) %> <%= name %>=
-				
+        
+        def _register<%= firstToUpper(name) %>(val)
+          @<%= name %> = [] unless @<%= name %>
+          @<%= name %>.push val
+        end
+
+        def _unregister<%= firstToUpper(name) %>(val)
+          @<%= name %>.delete val
+        end
+        
 			CODE
-			_class_module.module_eval(@@many_write_builder.result(binding))
+			self::ClassModule.module_eval(@@many_write_builder.result(binding))
 		end		
 				
 	end	
-	
+  
 	private
 
 	def build_derived_method(name, props, kind)
@@ -392,7 +405,7 @@ module BuilderExtensions
 			#TODO final_method :<%= name %>
 			
 		CODE
-		_class_module.module_eval(@@derived_builder.result(binding))
+		self::ClassModule.module_eval(@@derived_builder.result(binding))
 	end
 	
 	def type_check_code(varname, props)

data/lib/rgen/metamodel_builder/builder_extensions.rb.bak

@@ -0,0 +1,437 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'erb'
+require 'rgen/metamodel_builder/metamodel_description.rb'
+
+module RGen
+
+module MetamodelBuilder
+
+# This module provides methods which can be used to setup a metamodel element.
+# The module is used to +extend+ MetamodelBuilder::MMBase, i.e. add the module's 
+# methods as class methods.
+# 
+# MetamodelBuilder::MMBase should be used as a start for new metamodel elements.
+# See MetamodelBuilder for an example.
+# 
+module BuilderExtensions
+	include NameHelper
+
+    class FeatureBlockEvaluator
+      def self.eval(block, props1, props2=nil)
+        return unless block
+        e = self.new(props1, props2)
+        e.instance_eval(&block)
+      end
+      def initialize(props1, props2)
+        @props1, @props2 = props1, props2
+      end
+      def annotation(hash)
+        @props1.annotations << Intermediate::Annotation.new(hash)
+      end
+      def opposite_annotation(hash)
+        raise "No opposite available" unless @props2
+        @props2.annotations << Intermediate::Annotation.new(hash)
+      end
+    end
+    
+	def has_attr(role, target_class=nil, raw_props={}, &block)
+		props = AttributeDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>role, :upperBound=>1}))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
+	end
+	
+	# Add a single attribute or unidirectional association.
+	# 'role' specifies the name which is used to access the attribute.
+	# 'target_class' specifies the type of objects which can be held by this attribute.
+	# If no target class is given, String will be default.
+	# 
+	# This class method adds the following instance methods, where 'role' is to be 
+	# replaced by the given role name:
+	# 	class#role	# getter
+	# 	class#role=(value)	# setter
+	# 
+	def has_one(role, target_class=nil, raw_props={}, &block)
+		props = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>role, :upperBound=>1, :containment=>false}))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
+	end
+
+	# Add an unidirectional _many_ association.
+	# 'role' specifies the name which is used to access the attribute.
+	# 'target_class' is optional and can be used to fix the type of objects which
+	# can be referenced by this association.
+	# 
+	# This class method adds the following instance methods, where 'role' is to be 
+	# replaced by the given role name:
+	# 	class#addRole(value)	
+	# 	class#removeRole(value)
+	# 	class#role	# getter, returns an array
+	# Note that the first letter of the role name is turned into an uppercase 
+	# for the add and remove methods.
+	# 
+	def has_many(role, target_class=nil, raw_props={}, &block)
+		props = ReferenceDescription.new(target_class, _setManyUpperBound(_ownProps(raw_props).merge({
+			:name=>role, :containment=>false})))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
+	end
+	
+	def contains_one_uni(role, target_class=nil, raw_props={}, &block)
+		props = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>role, :upperBound=>1, :containment=>true}))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
+	end
+
+	def contains_many_uni(role, target_class=nil, raw_props={}, &block)
+		props = ReferenceDescription.new(target_class, _setManyUpperBound(_ownProps(raw_props).merge({
+			:name=>role, :containment=>true})))
+		raise "No opposite available" unless _oppositeProps(raw_props).empty?
+		FeatureBlockEvaluator.eval(block, props)
+		_build_internal(props)
+	end
+	
+	# Add a bidirectional one-to-many association between two classes.
+	# The class this method is called on is refered to as _own_class_ in 
+	# the following.
+	# 
+	# Instances of own_class can use 'own_role' to access _many_ associated instances
+	# of type 'target_class'. Instances of 'target_class' can use 'target_role' to
+	# access _one_ associated instance of own_class.
+	# 
+	# This class method adds the following instance methods where 'ownRole' and
+	# 'targetRole' are to be replaced by the given role names:
+	# 	own_class#addOwnRole(value)
+	# 	own_class#removeOwnRole(value)
+	# 	own_class#ownRole
+	# 	target_class#targetRole
+	# 	target_class#targetRole=(value)
+	# Note that the first letter of the role name is turned into an uppercase 
+	# for the add and remove methods.
+	# 
+	# When an element is added/set on either side, this element also receives the element
+	# is is added to as a new element.
+	# 
+	def one_to_many(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _setManyUpperBound(_ownProps(raw_props).merge({
+			:name=>target_role, :containment=>false})))
+		props2 = ReferenceDescription.new(self, _oppositeProps(raw_props).merge({
+			:name=>own_role, :upperBound=>1, :containment=>false}))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
+	end
+
+	def contains_many(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _setManyUpperBound(_ownProps(raw_props).merge({
+			:name=>target_role, :containment=>true})))
+		props2 = ReferenceDescription.new(self, _oppositeProps(raw_props).merge({
+			:name=>own_role, :upperBound=>1, :containment=>false}))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
+	end
+	
+	# This is the inverse of one_to_many provided for convenience.
+	def many_to_one(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>target_role, :upperBound=>1, :containment=>false}))
+		props2 = ReferenceDescription.new(self, _setManyUpperBound(_oppositeProps(raw_props).merge({
+			:name=>own_role, :containment=>false})))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
+	end
+	
+	# Add a bidirectional many-to-many association between two classes.
+	# The class this method is called on is refered to as _own_class_ in 
+	# the following.
+	# 
+	# Instances of own_class can use 'own_role' to access _many_ associated instances
+	# of type 'target_class'. Instances of 'target_class' can use 'target_role' to
+	# access _many_ associated instances of own_class.
+	# 
+	# This class method adds the following instance methods where 'ownRole' and
+	# 'targetRole' are to be replaced by the given role names:
+	# 	own_class#addOwnRole(value)
+	# 	own_class#removeOwnRole(value)
+	# 	own_class#ownRole
+	# 	target_class#addTargetRole
+	# 	target_class#removeTargetRole=(value)
+	# 	target_class#targetRole
+	# Note that the first letter of the role name is turned into an uppercase 
+	# for the add and remove methods.
+	# 
+	# When an element is added on either side, this element also receives the element
+	# is is added to as a new element.
+	# 
+	def many_to_many(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _setManyUpperBound(_ownProps(raw_props).merge({
+			:name=>target_role, :containment=>false})))
+		props2 = ReferenceDescription.new(self, _setManyUpperBound(_oppositeProps(raw_props).merge({
+			:name=>own_role, :containment=>false})))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
+	end
+	
+	# Add a bidirectional one-to-one association between two classes.
+	# The class this method is called on is refered to as _own_class_ in 
+	# the following.
+	# 
+	# Instances of own_class can use 'own_role' to access _one_ associated instance
+	# of type 'target_class'. Instances of 'target_class' can use 'target_role' to
+	# access _one_ associated instance of own_class.
+	# 
+	# This class method adds the following instance methods where 'ownRole' and
+	# 'targetRole' are to be replaced by the given role names:
+	# 	own_class#ownRole
+	# 	own_class#ownRole=(value)
+	# 	target_class#targetRole
+	# 	target_class#targetRole=(value)
+	# 
+	# When an element is set on either side, this element also receives the element
+	# is is added to as the new element.
+	# 
+	def one_to_one(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>target_role, :upperBound=>1, :containment=>false}))
+		props2 = ReferenceDescription.new(self, _oppositeProps(raw_props).merge({
+			:name=>own_role, :upperBound=>1, :containment=>false}))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
+	end
+	
+	def contains_one(target_role, target_class, own_role, raw_props={}, &block)
+		props1 = ReferenceDescription.new(target_class, _ownProps(raw_props).merge({
+			:name=>target_role, :upperBound=>1, :containment=>true}))
+		props2 = ReferenceDescription.new(self, _oppositeProps(raw_props).merge({
+			:name=>own_role, :upperBound=>1, :containment=>false}))
+		FeatureBlockEvaluator.eval(block, props1, props2)
+		_build_internal(props1, props2)
+	end
+		
+	def _metamodel_description # :nodoc:
+		@metamodel_description ||= []
+	end
+	
+	def inherited(c)
+	   c._class_module
+	end
+		
+	def _class_module # :nodoc:
+        unless const_defined?(:ClassModule)
+          const_set(:ClassModule, Module.new)
+          include const_get(:ClassModule)
+        end
+        const_get(:ClassModule)
+    end
+		
+	protected
+		
+	# Central builder method
+	# 
+	def _build_internal(props1, props2=nil)
+		_metamodel_description << props1
+		if props1.is_a?(ReferenceDescription) && props1.many?
+			_build_many_methods(props1, props2)
+		else
+			_build_one_methods(props1, props2)
+		end
+		if props2
+			# this is a bidirectional reference
+			props1.opposite, props2.opposite = props2, props1
+			other_class = props1.impl_type			
+			other_class._metamodel_description << props2
+			raise "Internal error: second description must be a ReferenceDescription" \
+				unless props2.is_a?(ReferenceDescription)
+			if props2.many?
+				other_class._build_many_methods(props2, props1)
+			else
+				other_class._build_one_methods(props2, props1)
+			end
+		end
+	end
+	
+	# To-One association methods
+	# 
+	def _build_one_methods(props, other_props=nil)
+		name = props.value(:name)
+		other_role = other_props && other_props.value(:name)
+		other_kind = other_props && ( other_props.many? ? :many : :one )
+
+		if props.value(:derived)
+			build_derived_method(name, props, :one)
+		else
+			@@one_read_builder ||= ERB.new <<-CODE
+			
+				def <%= name %>
+				  <% if props.is_a?(AttributeDescription) && props.value(:defaultValueLiteral) %>
+					<% defVal = props.value(:defaultValueLiteral) %>
+                    <% defVal = '"'+defVal+'"' if props.impl_type == String %>
+                    <% defVal = ':'+defVal if props.impl_type.is_a?(DataTypes::Enum) && props.impl_type != DataTypes::Boolean %>
+					@<%= name %>.nil? ? <%= defVal %> : @<%= name %>
+				  <% else %>
+				    @<%= name %>
+				  <% end %>
+				end
+				alias get<%= firstToUpper(name) %> <%= name %>
+
+			CODE
+			_class_module.module_eval(@@one_read_builder.result(binding))
+		end
+		
+		if props.value(:changeable)
+			@@one_write_builder ||= ERB.new <<-CODE
+				
+				def <%= name %>=(val)
+					return if val == @<%= name %>
+					<%= type_check_code("val", props) %>
+					oldval = @<%= name %>
+					@<%= name %> = val
+					<% if other_role && other_kind %>
+						_unregister(self,oldval,"<%= other_role %>","<%= other_kind %>")
+						_register(self,val,"<%= other_role %>","<%= other_kind %>")
+					<% end %>
+				end 
+				alias set<%= firstToUpper(name) %> <%= name %>=
+				
+			CODE
+			_class_module.module_eval(@@one_write_builder.result(binding))
+
+		end
+	end
+	
+	# To-Many association methods
+	# 
+	def _build_many_methods(props, other_props=nil)
+		name = props.value(:name)
+		other_role = other_props && other_props.value(:name)
+		other_kind = other_props && ( other_props.many? ? :many : :one )
+
+		if props.value(:derived)
+			build_derived_method(name, props, :many)
+		else
+			@@many_read_builder ||= ERB.new <<-CODE
+			
+				def <%= name %>
+					( @<%= name %> ? @<%= name %>.dup : [] )
+				end
+				alias get<%= firstToUpper(name) %> <%= name %>
+							
+			CODE
+			_class_module.module_eval(@@many_read_builder.result(binding))
+		end
+		
+		if props.value(:changeable)
+			@@many_write_builder ||= ERB.new <<-CODE
+		
+				def add<%= firstToUpper(name) %>(val)
+					@<%= name %> = [] unless @<%= name %>
+					return if val.nil? or @<%= name %>.include?(val) 
+					<%= type_check_code("val", props) %>
+					@<%= name %>.push val
+					<% if other_role && other_kind %>
+						_register(self, val, "<%= other_role %>", "<%= other_kind %>")
+					<% end %>
+				end
+				
+				def remove<%= firstToUpper(name) %>(val)
+					@<%= name %> = [] unless @<%= name %>
+					return unless @<%= name %>.include?(val)
+					@<%= name %>.delete val
+					<% if other_role && other_kind %>
+						_unregister(self, val, "<%= other_role %>", "<%= other_kind %>")
+					<% end %>
+				end
+				
+				def <%= name %>=(val)
+					return if val.nil?
+					raise _assignmentTypeError(self, val, Array) unless val.is_a? Array
+					getGeneric(:<%= name %>).each {|e|
+						remove<%= firstToUpper(name) %>(e)
+					}
+					val.each {|v|
+						add<%= firstToUpper(name) %>(v)
+					}
+				end
+				alias set<%= firstToUpper(name) %> <%= name %>=
+				
+			CODE
+			_class_module.module_eval(@@many_write_builder.result(binding))
+		end		
+				
+	end	
+	
+	private
+
+	def build_derived_method(name, props, kind)
+		raise "Implement method #{name}_derived instead of method #{name}" \
+			if (public_instance_methods+protected_instance_methods+private_instance_methods).include?(name)
+		@@derived_builder ||= ERB.new <<-CODE
+		
+			def <%= name %>
+				raise "Derived feature requires public implementation of method <%= name %>_derived" \
+					unless respond_to?(:<%= name+"_derived" %>)
+				val = <%= name %>_derived
+				<% if kind == :many %>
+					raise _assignmentTypeError(self,val,Array) unless val && val.is_a?(Array)
+					val.each do |v|
+						<%= type_check_code("v", props) %>
+					end
+				<% else %>
+					<%= type_check_code("val", props) %>
+				<% end %>	
+				val
+			end
+			alias get<%= firstToUpper(name) %> <%= name %>
+			#TODO final_method :<%= name %>
+			
+		CODE
+		_class_module.module_eval(@@derived_builder.result(binding))
+	end
+	
+	def type_check_code(varname, props)
+		code = ""
+		if props.impl_type.is_a?(Class)
+			code << "unless #{varname}.nil? or #{varname}.is_a? #{props.impl_type}\n"
+			expected = props.impl_type.to_s
+		elsif props.impl_type.is_a?(RGen::MetamodelBuilder::DataTypes::Enum)
+			code << "unless #{varname}.nil? or [#{props.impl_type.literals_as_strings.join(',')}].include?(#{varname})\n"
+		    expected = "["+props.impl_type.literals_as_strings.join(',')+"]"
+		else
+			raise StandardError.new("Unkown type "+props.impl_type.to_s)
+		end
+		code << "raise _assignmentTypeError(self,#{varname},\"#{expected}\")\n"
+		code << "end"
+		code		
+	end	
+	
+	def _ownProps(props)
+	  Hash[*(props.select{|k,v| !(k.to_s =~ /^opposite_/)}.flatten)]
+  end
+
+	def _oppositeProps(props)
+    r = {}
+	  props.each_pair do |k,v|
+      if k.to_s =~ /^opposite_(.*)$/
+        r[$1.to_sym] = v
+      end
+    end
+    r
+  end
+
+  def _setManyUpperBound(props)
+    props[:upperBound] = -1 unless props[:upperBound].is_a?(Integer) && props[:upperBound] > 1
+    props
+  end
+    
+end
+
+end
+
+end