puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

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

@@ -1,26 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,28 +0,0 @@
-$:.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

@@ -1,37 +0,0 @@
-<% 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

@@ -1,172 +0,0 @@
-
-<% 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

@@ -1,45 +0,0 @@
-# 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

@@ -1,218 +0,0 @@
-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