RGen::ECore::ECoreToRuby

# File lib/rgen/ecore/ecore_to_ruby.rb, line 9
def initialize
  @modules = {}
  @classifiers = {}
  @features_added = {}
  @in_create_module = false
end

# File lib/rgen/ecore/ecore_to_ruby.rb, line 128
def add_features(eclass)
  return false if @features_added[eclass]
  c = @classifiers[eclass]
  eclass.eStructuralFeatures.each do |f|
    w1 = FeatureWrapper.new(f, @classifiers) 
    w2 = FeatureWrapper.new(f.eOpposite, @classifiers) if f.is_a?(RGen::ECore::EReference) && f.eOpposite
    c.module_eval do
      if w1.many
        _build_many_methods(w1, w2)
      else
        _build_one_methods(w1, w2)
      end
    end
  end
  @features_added[eclass] = true
  eclass.eSuperTypes.each do |t|
    add_features(t)
  end
  true
end

# File lib/rgen/ecore/ecore_to_ruby.rb, line 47
def create_class(eclass)
  return @classifiers[eclass] if @classifiers[eclass]

  c = Class.new(super_class(eclass)) do
    abstract if eclass.abstract
    class << self
      attr_accessor :_ecore_to_ruby
    end
  end
  class << eclass
    attr_accessor :instanceClass
    def instanceClassName
      instanceClass.to_s
    end
  end
  eclass.instanceClass = c
  c::ClassModule.module_eval do
    alias _method_missing method_missing
    def method_missing(m, *args)
      if self.class._ecore_to_ruby.add_features(self.class.ecore)
        send(m, *args)
      else
        _method_missing(m, *args)
      end
    end
    alias _respond_to respond_to?
    def respond_to?(m)
      self.class._ecore_to_ruby.add_features(self.class.ecore)
      _respond_to(m)
    end
  end
  @classifiers[eclass] = c
  c._set_ecore_internal(eclass)
  c._ecore_to_ruby = self

  create_module(eclass.ePackage).const_set(eclass.name, c)
  c
end

# File lib/rgen/ecore/ecore_to_ruby.rb, line 86
def create_enum(eenum)
  return @classifiers[eenum] if @classifiers[eenum]

  e = RGen::MetamodelBuilder::DataTypes::Enum.new(eenum.eLiterals.collect{|l| l.name.to_sym})
  @classifiers[eenum] = e

  create_module(eenum.ePackage).const_set(eenum.name, e)
  e
end

# File lib/rgen/ecore/ecore_to_ruby.rb, line 16
def create_module(epackage)
  return @modules[epackage] if @modules[epackage]
  
  top = (@in_create_module == false)
  @in_create_module = true

  m = Module.new do
    extend RGen::MetamodelBuilder::ModuleExtension
  end
  @modules[epackage] = m

  epackage.eSubpackages.each{|p| create_module(p)}
  m._set_ecore_internal(epackage)

  create_module(epackage.eSuperPackage).const_set(epackage.name, m) if epackage.eSuperPackage

  # create classes only after all modules have been created
  # otherwise classes may be created multiple times
  if top
    epackage.eAllClassifiers.each do |c| 
      if c.is_a?(RGen::ECore::EClass)
        create_class(c)
      elsif c.is_a?(RGen::ECore::EEnum)
        create_enum(c)
      end
    end
    @in_create_module = false
  end
  m
end

# File lib/rgen/ecore/ecore_to_ruby.rb, line 65
def method_missing(m, *args)
  if self.class._ecore_to_ruby.add_features(self.class.ecore)
    send(m, *args)
  else
    _method_missing(m, *args)
  end
end

# File lib/rgen/ecore/ecore_to_ruby.rb, line 73
def respond_to?(m)
  self.class._ecore_to_ruby.add_features(self.class.ecore)
  _respond_to(m)
end

# File lib/rgen/ecore/ecore_to_ruby.rb, line 149
def super_class(eclass)
  super_types = eclass.eSuperTypes
  case super_types.size
  when 0
    RGen::MetamodelBuilder::MMBase
  when 1
    create_class(super_types.first)
  else
    RGen::MetamodelBuilder::MMMultiple(*super_types.collect{|t| create_class(t)})
  end
end