puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/vendor/rgen/lib/metamodels/uml13_metamodel_ext.rb

@@ -0,0 +1,26 @@
+# Some handy extensions to the UML13 metamodel
+# 
+module UML13
+  
+  module AssociationEnd::ClassModule
+    def otherEnd
+      association.connection.find{|c| c != self}
+    end
+  end
+  
+  module Classifier::ClassModule
+    def localCompositeEnd
+      associationEnd.select{|e| e.aggregation == :composite}
+    end
+    def remoteCompositeEnd
+      associationEnd.otherEnd.select{|e| e.aggregation == :composite}
+    end
+    def localNavigableEnd
+      associationEnd.select{|e| e.isNavigable}
+    end
+    def remoteNavigableEnd
+      associationEnd.otherEnd.select{|e| e.isNavigable}
+    end
+  end
+
+end

data/lib/puppet/vendor/rgen/lib/mmgen/metamodel_generator.rb

@@ -0,0 +1,20 @@
+require 'rgen/environment'
+require 'rgen/template_language'
+require 'rgen/ecore/ecore'
+require 'rgen/ecore/ecore_ext'
+require 'mmgen/mm_ext/ecore_mmgen_ext'
+
+module MMGen
+
+module MetamodelGenerator
+
+	def generateMetamodel(rootPackage, out_file)
+		tc = RGen::TemplateLanguage::DirectoryTemplateContainer.new(RGen::ECore, File.dirname(out_file))
+		tpl_path = File.dirname(__FILE__) + '/templates'
+		tc.load(tpl_path)
+		tc.expand('metamodel_generator::GenerateMetamodel', File.basename(out_file), :for => rootPackage)
+	end
+
+end
+
+end

data/lib/puppet/vendor/rgen/lib/mmgen/mm_ext/ecore_mmgen_ext.rb

@@ -0,0 +1,91 @@
+require 'rgen/util/name_helper'
+
+module RGen
+  
+  module ECore
+    
+    module EPackage::ClassModule
+      include RGen::Util::NameHelper
+      
+      def moduleName
+        firstToUpper(name)
+      end
+      
+      def qualifiedModuleName(rootPackage)
+        return moduleName unless eSuperPackage and self != rootPackage
+        eSuperPackage.qualifiedModuleName(rootPackage) + "::" + moduleName
+      end
+      
+      def ancestorPackages
+        return [] unless eSuperPackage
+        [eSuperPackage] + eSuperPackage.ancestorPackages
+      end
+      
+      def ownClasses
+        eClassifiers.select{|c| c.is_a?(EClass)}
+      end
+      
+      def classesInGenerationOrdering
+        ownClasses + eSubpackages.collect{|s| s.classesInGenerationOrdering}.flatten
+      end
+      
+      def needClassReorder?
+        classesInGenerationOrdering != inheritanceOrderClasses(classesInGenerationOrdering)
+      end
+      
+      def allClassesSorted
+        inheritanceOrderClasses(classesInGenerationOrdering)
+      end
+      
+      def inheritanceOrderClasses(cls)
+        sortArray = cls.dup
+        i1 = 0
+        while i1 < sortArray.size-1
+          again = false
+          for i2 in i1+1..sortArray.size-1
+            e2 = sortArray[i2]
+            if sortArray[i1].eSuperTypes.include?(e2)
+              sortArray.delete(e2)
+              sortArray.insert(i1,e2)
+              again = true
+              break
+            end
+          end
+          i1 += 1 unless again
+        end
+        sortArray
+      end
+    end
+    
+    module EClassifier::ClassModule
+      include RGen::Util::NameHelper
+      def classifierName
+        firstToUpper(name)			
+      end
+      def qualifiedClassifierName(rootPackage)
+       (ePackage ? ePackage.qualifiedModuleName(rootPackage) + "::" : "") + classifierName
+      end
+      def ancestorPackages
+        return [] unless ePackage
+        [ePackage] + ePackage.ancestorPackages
+      end
+      def qualifiedClassifierNameIfRequired(package)
+        if ePackage != package
+          commonSuper = (package.ancestorPackages & ancestorPackages).first
+          qualifiedClassifierName(commonSuper)
+        else
+          classifierName
+        end
+      end
+    end
+    
+    module EAttribute::ClassModule
+      def RubyType
+        typeMap = {'float' => 'Float', 'int' => 'Integer'}
+         (self.getType && typeMap[self.getType.downcase]) || 'String'
+      end
+    end
+    
+  end
+  
+end

data/lib/puppet/vendor/rgen/lib/mmgen/mmgen.rb

@@ -0,0 +1,28 @@
+$:.unshift File.join(File.dirname(__FILE__),"..")
+
+require 'ea/xmi_ecore_instantiator'
+require 'mmgen/metamodel_generator'
+
+include MMGen::MetamodelGenerator
+
+unless ARGV.length >= 2
+	puts "Usage: mmgen.rb <xmi_class_model_file> <root package> (<module>)*"
+	exit
+else
+	file_name = ARGV.shift
+	root_package_name = ARGV.shift
+	modules = ARGV
+	out_file = file_name.gsub(/\.\w+$/,'.rb')
+	puts out_file
+end
+
+env = RGen::Environment.new
+File.open(file_name) { |f|
+    puts "instantiating ..."
+	XMIECoreInstantiator.new.instantiateECoreModel(env, f.read)
+}
+
+rootPackage = env.find(:class => RGen::ECore::EPackage, :name => root_package_name).first
+
+puts "generating ..."
+generateMetamodel(rootPackage, out_file, modules)

data/lib/puppet/vendor/rgen/lib/mmgen/templates/annotations.tpl

@@ -0,0 +1,37 @@
+<% define 'Annotations', :for => EPackage do %>
+	<% for a in eAnnotations %>
+		annotation <% expand 'AnnotationArgs', :for => a %>
+	<% end %>
+<% end %>
+
+<% define 'Annotations', :for => EClass do %>
+	<% for a in eAnnotations %>
+		annotation <% expand 'AnnotationArgs', :for => a %>
+	<% end %>
+<% end %>
+
+<% define 'Annotations', :for => EStructuralFeature do %>
+	<% oppositeAnnotations = (this.respond_to?(:eOpposite) && eOpposite && eOpposite.eAnnotations) || [] %>
+	<% if eAnnotations.size > 0 || oppositeAnnotations.size > 0 %>
+		do<%iinc%>
+			<% for a in eAnnotations %>
+				annotation <% expand 'AnnotationArgs', :for => a %>
+			<% end %>
+			<% for a in oppositeAnnotations %>
+				opposite_annotation <% expand 'AnnotationArgs', :for => a %>
+			<% end %><%idec%>
+		end<%nows%>
+	<% end %>
+<% end %>
+
+<% define 'AnnotationArgs', :for => EAnnotation do %>
+	<% if source.nil? %>
+		<% expand 'Details' %>
+	<% else %>
+		:source => "<%= source.to_s %>", :details => {<% expand 'Details' %>}<%nows%>
+	<% end %>
+<% end %>
+
+<% define 'Details', :for => EAnnotation do %>
+	<%= details.sort{|a,b| a.key<=>b.key}.collect{ |d| "\'" + d.key + "\' => \'"+ (d.value || "").gsub('\'','\\\'').to_s + "\'"}.join(', ') %><%nows%>
+<% end %>

data/lib/puppet/vendor/rgen/lib/mmgen/templates/metamodel_generator.tpl

@@ -0,0 +1,172 @@
+
+<% define 'GenerateMetamodel', :for => EPackage do |filename| %>
+  <% file filename do %>
+    require 'rgen/metamodel_builder'
+    <%nl%>
+    <% if needClassReorder? %>
+      <% expand 'GeneratePackagesOnly' %>
+      <% expand 'GenerateClassesReordered' %>
+    <% else %>
+      <% expand 'GeneratePackage' %>
+    <% end %>
+    <%nl%>
+    <% expand 'GenerateAssocs' %>
+  <% end %>
+<% end %>
+    
+<% define 'GeneratePackage', :for => EPackage do %>
+  module <%= moduleName %><% iinc %>
+    extend RGen::MetamodelBuilder::ModuleExtension
+    include RGen::MetamodelBuilder::DataTypes
+    <% expand 'annotations::Annotations' %>
+    <%nl%>
+    <% expand 'EnumTypes' %>
+    <% for c in ownClasses %><%nl%>
+      <% expand 'ClassHeader', this, :for => c %><%iinc%>
+        <% if c.abstract %>abstract<% end %>
+        <% expand 'annotations::Annotations', :for => c %>
+        <% expand 'Attribute', this, :foreach => c.eAttributes %>
+        <%idec%>
+      end
+    <% end %><%nl%>
+    <% for p in eSubpackages %>
+      <%nl%><% expand 'GeneratePackage', :for => p %>
+    <% end %><%idec%>
+  end
+<% end %>
+
+<% define 'GenerateClassesReordered', :for => EPackage do %>
+  <% for c in allClassesSorted %><%nl%>
+    <% expand 'ClassHeaderFullyQualified', this, :for => c %><%iinc%>
+      <% if c.abstract %>abstract<% end %>
+      <% expand 'annotations::Annotations', :for => c %>
+      <% expand 'Attribute', this, :foreach => c.eAttributes %>
+      <%idec%>
+    end
+  <% end %><%nl%>
+<% end %>
+
+<% define 'GeneratePackagesOnly', :for => EPackage do %>
+  module <%= moduleName %><% iinc %>
+    extend RGen::MetamodelBuilder::ModuleExtension
+    include RGen::MetamodelBuilder::DataTypes
+    <% expand 'annotations::Annotations' %>
+    <%nl%>
+    <% expand 'EnumTypes' %>
+    <% for p in eSubpackages %>
+      <%nl%><% expand 'GeneratePackagesOnly', :for => p %>
+    <% end %><%idec%>
+  end
+<% end %>
+
+<% define 'Attribute', :for => EAttribute do |rootp| %>
+  <% if upperBound == 1%>has_attr<% else %>has_many_attr<% end %> '<%= name %>', <%nows%>
+  <% if eType.is_a?(EEnum) %><%nows%>
+    <%= eType.qualifiedClassifierName(rootp) %><%nows%>
+  <% else %><%nows%>
+    <%= eType && eType.instanceClass.to_s %><%nows%>
+  <% end %><%nows%>
+  <% for p in RGen::MetamodelBuilder::Intermediate::Attribute.properties %>
+    <% unless p == :name || (p == :upperBound && (upperBound == 1 || upperBound == -1)) || 
+      RGen::MetamodelBuilder::Intermediate::Attribute.default_value(p) == getGeneric(p) %>
+        , :<%=p%> => <%nows%>
+        <% if getGeneric(p).is_a?(String) %>
+          "<%= getGeneric(p) %>"<%nows%>
+        <% elsif getGeneric(p).is_a?(Symbol) %>
+          :<%= getGeneric(p) %><%nows%>
+        <% else %>
+          <%= getGeneric(p) %><%nows%>
+        <% end %>
+    <% end %>
+  <% end %>
+  <%ws%><% expand 'annotations::Annotations' %><%nl%>
+<% end %>
+
+<% define 'EnumTypes', :for => EPackage do %>
+  <% for enum in eClassifiers.select{|c| c.is_a?(EEnum)} %>
+    <%= enum.name %> = Enum.new(:name => '<%= enum.name %>', :literals =>[ <%nows%>
+    <%= enum.eLiterals.collect { |lit| ":"+(lit.name =~ /^\d|\W/ ? "'"+lit.name+"'" : lit.name) }.join(', ') %> ])
+  <% end %>
+<% end %>
+
+<% define 'GenerateAssocs', :for => EPackage do %>
+  <% refDone = {} %>
+  <% for ref in eAllClassifiers.select{|c| c.is_a?(EClass)}.eReferences %>
+    <% if !refDone[ref] && ref.eOpposite %>
+      <% ref = ref.eOpposite if ref.eOpposite.containment %>
+      <% refDone[ref] = refDone[ref.eOpposite] = true %>
+      <% if !ref.many && !ref.eOpposite.many %>
+        <% if ref.containment %>
+          <% expand 'Reference', "contains_one", this, :for => ref %>
+        <% else %>
+          <% expand 'Reference', "one_to_one", this, :for => ref %>
+        <% end %>
+      <% elsif !ref.many && ref.eOpposite.many %>
+        <% expand 'Reference', "many_to_one", this, :for => ref %>
+      <% elsif ref.many && !ref.eOpposite.many %>
+        <% if ref.containment %>
+          <% expand 'Reference', "contains_many", this, :for => ref %>
+        <% else %>
+          <% expand 'Reference', "one_to_many", this, :for => ref %>
+        <% end %>
+      <% elsif ref.many && ref.eOpposite.many %>
+        <% expand 'Reference', "many_to_many", this, :for => ref %>
+      <% end %>
+      <% expand 'annotations::Annotations', :for => ref %><%nl%>
+    <% elsif !refDone[ref] %>
+      <% refDone[ref] = true %>
+      <% if !ref.many %>
+        <% if ref.containment %>
+          <% expand 'Reference', "contains_one_uni", this, :for => ref %>
+        <% else %>
+          <% expand 'Reference', "has_one", this, :for => ref %>
+        <% end %>
+      <% elsif ref.many %>
+        <% if ref.containment %>
+          <% expand 'Reference', "contains_many_uni", this, :for => ref %>
+        <% else %>
+          <% expand 'Reference', "has_many", this, :for => ref %>
+        <% end %>
+      <% end %>
+      <% expand 'annotations::Annotations', :for => ref %><%nl%>
+    <% end %>
+  <% end %>
+<% end %>
+
+<% define 'Reference', :for => EReference do |cmd, rootpackage| %>
+  <%= eContainingClass.qualifiedClassifierName(rootpackage) %>.<%= cmd %> '<%= name %>', <%= eType && eType.qualifiedClassifierName(rootpackage) %><%nows%>
+  <% if eOpposite %><%nows%>
+    , '<%= eOpposite.name%>'<%nows%>
+  <% end %><%nows%>
+  <% pset = RGen::MetamodelBuilder::Intermediate::Reference.properties.reject{|p| p == :name || p == :upperBound || p == :containment} %>
+  <% for p in pset.reject{|p| RGen::MetamodelBuilder::Intermediate::Reference.default_value(p) == getGeneric(p)} %>
+      , :<%=p%> => <%=getGeneric(p)%><%nows%>
+  <% end %>
+  <% if eOpposite %>
+    <% for p in pset.reject{|p| RGen::MetamodelBuilder::Intermediate::Reference.default_value(p) == eOpposite.getGeneric(p)} %>
+        , :opposite_<%=p%> => <%=eOpposite.getGeneric(p)%><%nows%>
+    <% end %>
+  <% end %><%ws%>
+<% end %>
+
+<% define 'ClassHeader', :for => EClass do |rootp| %>
+  class <%= classifierName %> < <% nows %>
+  <% if eSuperTypes.size > 1 %><% nows %>
+    RGen::MetamodelBuilder::MMMultiple(<%= eSuperTypes.collect{|t| t.qualifiedClassifierNameIfRequired(rootp)}.join(', ') %>)
+  <% elsif eSuperTypes.size > 0 %><% nows %>
+    <%= eSuperTypes.first.qualifiedClassifierNameIfRequired(rootp) %>
+  <% else %><% nows %>
+    RGen::MetamodelBuilder::MMBase
+  <% end %>
+<% end %>
+
+<% define 'ClassHeaderFullyQualified', :for => EClass do |rootp| %>
+  class <%= qualifiedClassifierName(rootp) %> < <% nows %>
+  <% if eSuperTypes.size > 1 %><% nows %>
+    RGen::MetamodelBuilder::MMMultiple(<%= eSuperTypes.collect{|t| t.qualifiedClassifierName(rootp)}.join(', ') %>)
+  <% elsif eSuperTypes.size > 0 %><% nows %>
+    <%= eSuperTypes.first.qualifiedClassifierName(rootp) %>
+  <% else %><% nows %>
+    RGen::MetamodelBuilder::MMBase
+  <% end %>
+<% end %>

data/lib/puppet/vendor/rgen/lib/rgen/array_extensions.rb

@@ -0,0 +1,45 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'rgen/metamodel_builder'
+
+class Array
+
+  def >>(method)
+    compact.inject([]) { |r,e| r | ( (o=e.send(method)).is_a?(Array) ? o : [o] ) }
+  end
+  
+  def method_missing(m, *args)
+
+    # This extensions has the side effect that it allows to call any method on any
+    # empty array with an empty array as the result. This behavior is required for
+    # navigating models.
+    #
+    # This is a problem for Hash[] called with an (empty) array of tupels.
+    # It will call to_hash expecting a Hash as the result. When it gets an array instead,
+    # it fails with an exception. Make sure it gets a NoMethodException as without this
+    # extension and it will catch that and return an empty hash as expected.
+    #
+    # Similar problems exist for other Ruby built-in methods which are expected to fail.
+    #
+    return super unless (size == 0 && 
+      m != :to_hash && m != :to_str) ||
+      compact.any?{|e| e.is_a? RGen::MetamodelBuilder::MMBase}
+    # use an array to build the result to achiev similar ordering
+    result = []
+    inResult = {}
+    compact.each do |e|
+      if e.is_a? RGen::MetamodelBuilder::MMBase        
+        ((o=e.send(m)).is_a?(Array) ? o : [o] ).each do |v|
+          next if inResult[v.object_id]
+          inResult[v.object_id] = true
+          result << v
+        end
+      else
+        raise StandardError.new("Trying to call a method on an array element not a RGen MMBase")
+      end
+    end
+    result.compact
+  end
+
+end

data/lib/puppet/vendor/rgen/lib/rgen/ecore/ecore.rb

@@ -0,0 +1,218 @@
+require 'rgen/metamodel_builder'
+
+module RGen
+  extend RGen::MetamodelBuilder::ModuleExtension
+  
+  # This is the ECore metamodel described using the RGen::MetamodelBuilder language.
+  #
+  # Known differences to the Java/EMF implementation are:
+  # * Attributes can not be "many"
+  # 
+  module ECore
+    extend RGen::MetamodelBuilder::ModuleExtension
+    
+    class EObject < RGen::MetamodelBuilder::MMBase
+    end
+    
+    class EModelElement < RGen::MetamodelBuilder::MMBase
+    end
+    
+    class EAnnotation < RGen::MetamodelBuilder::MMMultiple(EModelElement, EObject)
+      has_attr 'source', String
+    end
+    
+    class ENamedElement < EModelElement
+      has_attr 'name', String
+    end
+    
+    class ETypedElement < ENamedElement
+      has_attr 'lowerBound', Integer, :defaultValueLiteral => "0"
+      has_attr 'ordered', Boolean, :defaultValueLiteral => "true"
+      has_attr 'unique', Boolean, :defaultValueLiteral => "true"
+      has_attr 'upperBound', Integer, :defaultValueLiteral => "1"
+      has_attr 'many', Boolean, :derived=>true
+      has_attr 'required', Boolean, :derived=>true
+      module ClassModule
+        def many_derived
+          upperBound > 1 || upperBound == -1
+        end
+        def required_derived
+          lowerBound > 0
+        end
+      end
+    end
+    
+    class EStructuralFeature < ETypedElement
+      has_attr 'changeable', Boolean, :defaultValueLiteral => "true"
+      has_attr 'defaultValue', Object, :derived=>true
+      has_attr 'defaultValueLiteral', String
+      has_attr 'derived', Boolean, :defaultValueLiteral => "false"
+      has_attr 'transient', Boolean, :defaultValueLiteral => "false"
+      has_attr 'unsettable', Boolean, :defaultValueLiteral => "false"
+      has_attr 'volatile', Boolean, :defaultValueLiteral => "false"
+      module ClassModule
+        def defaultValue_derived
+          return nil if defaultValueLiteral.nil?
+          case eType
+            when EInt, ELong
+              defaultValueLiteral.to_i
+            when EFloat
+              defaultValueLiteral.to_f
+            when EEnum
+              defaultValueLiteral.to_sym
+            when EBoolean
+              defaultValueLiteral == "true"
+            when EString
+              defaultValueLiteral
+            else
+              raise "Unhandled type"
+            end
+        end
+      end
+    end
+    
+    class EAttribute < EStructuralFeature
+      has_attr 'iD', Boolean, :defaultValueLiteral => "false"
+    end
+    
+    class EClassifier < ENamedElement
+      has_attr 'defaultValue', Object, :derived=>true
+      has_attr 'instanceClass', Object, :derived=>true
+      has_attr 'instanceClassName', String
+      module ClassModule
+        def instanceClass_derived
+          map = {"java.lang.string" => "String", 
+                 "boolean" => "RGen::MetamodelBuilder::DataTypes::Boolean", 
+                 "int" => "Integer",
+                 "long" => "RGen::MetamodelBuilder::DataTypes::Long"}
+          icn = instanceClassName
+          icn = "NilClass" if icn.nil?
+          icn = map[icn.downcase] if map[icn.downcase]
+          eval(icn)
+        end
+      end
+    end
+    
+    class EDataType < EClassifier
+      has_attr 'serializable', Boolean
+    end
+
+    class EGenericType < EDataType
+      has_one 'eClassifier', EDataType
+    end
+
+    class ETypeArgument < EModelElement
+      has_one 'eClassifier', EDataType
+    end
+    
+    class EEnum < EDataType
+    end
+    
+    class EEnumLiteral < ENamedElement
+      # instance may point to a "singleton object" (e.g. a Symbol) representing the literal
+      #      has_attr 'instance', Object, :eType=>:EEnumerator, :transient=>true
+      has_attr 'literal', String
+      has_attr 'value', Integer
+    end
+    
+    # TODO: check if required
+    class EFactory < EModelElement
+    end
+    
+    class EOperation < ETypedElement
+    end
+    
+    class EPackage < ENamedElement
+      has_attr 'nsPrefix', String
+      has_attr 'nsURI', String
+    end
+    
+    class EParameter < ETypedElement
+    end
+    
+    class EReference < EStructuralFeature
+      has_attr 'container', Boolean, :derived=>true
+      has_attr 'containment', Boolean, :defaultValueLiteral => "false"
+      has_attr 'resolveProxies', Boolean, :defaultValueLiteral => "true"
+    end
+    
+    class EStringToStringMapEntry < RGen::MetamodelBuilder::MMBase
+      has_attr 'key', String
+      has_attr 'value', String
+    end
+    
+    class EClass < EClassifier
+      has_attr 'abstract', Boolean
+      has_attr 'interface', Boolean
+      has_one  'eIDAttribute', ECore::EAttribute, :derived=>true, :resolveProxies=>false
+      
+      has_many 'eAllAttributes', ECore::EAttribute, :derived=>true
+      has_many 'eAllContainments', ECore::EReference, :derived=>true
+      has_many 'eAllOperations', ECore::EOperation, :derived=>true
+      has_many 'eAllReferences', ECore::EReference, :derived=>true
+      has_many 'eAllStructuralFeatures', ECore::EStructuralFeature, :derived=>true
+      has_many 'eAllSuperTypes', ECore::EClass, :derived=>true
+      has_many 'eAttributes', ECore::EAttribute, :derived=>true
+      has_many 'eReferences', ECore::EReference, :derived=>true
+      
+      module ClassModule		
+        def eAllAttributes_derived
+          eAttributes + eSuperTypes.eAllAttributes
+        end
+        def eAllContainments_derived
+          eReferences.select{|r| r.containment} + eSuperTypes.eAllContainments
+        end
+        def eAllReferences_derived
+          eReferences + eSuperTypes.eAllReferences
+        end
+        def eAllStructuralFeatures_derived
+          eStructuralFeatures + eSuperTypes.eAllStructuralFeatures
+        end
+        def eAllSuperTypes_derived
+          eSuperTypes + eSuperTypes.eAllSuperTypes
+        end
+        def eAttributes_derived
+          eStructuralFeatures.select{|f| f.is_a?(EAttribute)}
+        end
+        def eReferences_derived
+          eStructuralFeatures.select{|f| f.is_a?(EReference)}
+        end
+      end
+    end
+    
+    # predefined datatypes
+    
+    EString = EDataType.new(:name => "EString", :instanceClassName => "String")
+    EInt = EDataType.new(:name => "EInt", :instanceClassName => "Integer")
+    ELong = EDataType.new(:name => "ELong", :instanceClassName => "Long")
+    EBoolean = EDataType.new(:name => "EBoolean", :instanceClassName => "Boolean")
+    EFloat = EDataType.new(:name => "EFloat", :instanceClassName => "Float")
+    ERubyObject = EDataType.new(:name => "ERubyObject", :instanceClassName => "Object")
+    EJavaObject = EDataType.new(:name => "EJavaObject")
+    ERubyClass = EDataType.new(:name => "ERubyClass", :instanceClassName => "Class")
+    EJavaClass = EDataType.new(:name => "EJavaClass")
+    
+  end
+  
+  ECore::EModelElement.contains_many 'eAnnotations', ECore::EAnnotation, 'eModelElement', :resolveProxies=>false
+  ECore::EAnnotation.contains_many_uni 'details', ECore::EStringToStringMapEntry, :resolveProxies=>false
+  ECore::EAnnotation.contains_many_uni 'contents', ECore::EObject, :resolveProxies=>false
+  ECore::EAnnotation.has_many 'references', ECore::EObject
+  ECore::EPackage.contains_many 'eClassifiers', ECore::EClassifier, 'ePackage'
+  ECore::EPackage.contains_many 'eSubpackages', ECore::EPackage, 'eSuperPackage'
+  ECore::ETypedElement.has_one 'eType', ECore::EClassifier
+  ECore::EClass.contains_many 'eOperations', ECore::EOperation, 'eContainingClass', :resolveProxies=>false
+  ECore::EClass.contains_many 'eStructuralFeatures', ECore::EStructuralFeature, 'eContainingClass', :resolveProxies=>false
+  ECore::EClass.has_many 'eSuperTypes', ECore::EClass
+  ECore::EEnum.contains_many 'eLiterals', ECore::EEnumLiteral, 'eEnum', :resolveProxies=>false
+  ECore::EFactory.one_to_one 'ePackage', ECore::EPackage, 'eFactoryInstance', :lowerBound=>1, :transient=>true, :resolveProxies=>false
+  ECore::EOperation.contains_many 'eParameters', ECore::EParameter, 'eOperation', :resolveProxies=>false
+  ECore::EOperation.has_many 'eExceptions', ECore::EClassifier
+  ECore::EReference.has_one 'eOpposite', ECore::EReference
+  
+  ECore::EAttribute.has_one 'eAttributeType', ECore::EDataType, :lowerBound=>1, :derived=>true
+  ECore::EReference.has_one 'eReferenceType', ECore::EClass, :lowerBound=>1, :derived=>true
+  ECore::EParameter.contains_one 'eGenericType', ECore::EGenericType, 'eParameter'
+  ECore::EGenericType.contains_many 'eTypeArguments', ECore::ETypeArgument, 'eGenericType'
+  
+end