class IDL::AST::Interface

Constants

DEFINABLE

Attributes

bases[R]
idltype[R]

Public Class Methods

new(_name, _enclosure, params) click to toggle source
Calls superclass method IDL::AST::Node::new
# File lib/ridl/node.rb, line 967
def initialize(_name, _enclosure, params)
  super(_name, _enclosure)
  @bases = []
  @resolved_bases = []
  @defined = !params[:forward]
  @abstract = params[:abstract]
  @pseudo = params[:pseudo]
  @local = params[:local]
  @idltype = IDL::Type::Interface.new(self)
  add_bases(params[:inherits] || [])
end

Public Instance Methods

add_bases(inherits_) click to toggle source
# File lib/ridl/node.rb, line 1027
   def add_bases(inherits_)
     inherits_.each do |tc|
       unless tc.is_a?(IDL::Type::ScopedName) && tc.is_node?(IDL::AST::TemplateParam)
         unless (tc.is_a?(IDL::Type::NodeType) && tc.is_node?(IDL::AST::Interface))
           raise "invalid inheritance identifier for #{typename} #{scoped_lm_name}: #{tc.typename}"
         end

         rtc = tc.resolved_type
         if rtc.node.has_ancestor?(self)
           raise "circular inheritance detected for #{typename} #{scoped_lm_name}: #{tc.node.scoped_lm_name} is descendant"
         end
         unless rtc.node.is_defined?
           raise "#{typename} #{scoped_lm_name} cannot inherit from forward declared #{tc.node.typename} #{tc.node.scoped_lm_name}"
         end
         if rtc.node.is_local? and not self.is_local?
           raise "#{typename} #{scoped_lm_name} cannot inherit from 'local' #{tc.node.typename} #{tc.node.scoped_lm_name}"
         end
         if rtc.node.is_pseudo? and not self.is_pseudo?
           raise "#{typename} #{scoped_lm_name} cannot inherit from 'pseudo' #{tc.node.typename} #{tc.node.scoped_lm_name}"
         end
         if self.is_abstract? and not rtc.node.is_abstract?
           raise "'abstract' #{typename} #{scoped_lm_name} cannot inherit from non-'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
         end
         if self.is_local? and rtc.node.is_abstract?
           raise "'local' #{typename} #{scoped_lm_name} cannot inherit from 'abstract' #{tc.node.typename} #{tc.node.scoped_lm_name}"
         end
         if self.has_base?(rtc.node)
           raise "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} multiple times"
         end

         # check if we indirectly derive from this base multiple times (which is ok; no further need to check)
         unless @resolved_bases.any? { |b| b.has_ancestor?(rtc.node) }
           # this is a new base so we need to check for member redefinition/ambiguity
           new_op_att_ = []
           rtc.node.walk_members do |m|
             new_op_att_ << m if m.is_a?(IDL::AST::Operation) || m.is_a?(IDL::AST::Attribute)
           end
           if new_op_att_.any? { |n| n_ = self.search_self(n.name)
n_.is_a?(IDL::AST::Operation) || n_.is_a?(IDL::AST::Attribute) }
             raise "#{typename} #{scoped_lm_name} cannot inherit from #{tc.node.typename} #{tc.node.scoped_lm_name} because of duplicated operations/attributes"
           end
           # no need to check for duplicate member names; this inheritance is ok
         end
         @resolved_bases << rtc.node
       end
       @bases << tc.node
     end
   end
ancestors() click to toggle source
# File lib/ridl/node.rb, line 1080
def ancestors
  @resolved_bases
end
attributes(include_bases = false, traversed = nil) click to toggle source
# File lib/ridl/node.rb, line 1090
def attributes(include_bases = false, traversed = nil)
  atts = @children.find_all { |c| c.is_a?(IDL::AST::Attribute) }
  atts.concat(base_attributes(traversed || [])) if include_bases
  atts
end
has_base?(_base) click to toggle source
# File lib/ridl/node.rb, line 1076
def has_base?(_base)
  @resolved_bases.any? { |b| b == _base.idltype.resolved_type.node }
end
instantiate(instantiation_context, _enclosure) click to toggle source
Calls superclass method IDL::AST::Leaf#instantiate
# File lib/ridl/node.rb, line 994
def instantiate(instantiation_context, _enclosure)
  _params = {
    forward: self.is_forward?,
    abstract: self.is_abstract?,
    pseudo: self.is_pseudo?,
    local: self.is_local?,
    inherits: self.concrete_bases(instantiation_context)
  }
  # instantiate concrete interface def and validate
  # concrete bases
  super(instantiation_context, _enclosure, _params)
end
is_abstract?() click to toggle source
# File lib/ridl/node.rb, line 1007
def is_abstract?
  @abstract
end
is_defined?() click to toggle source
# File lib/ridl/node.rb, line 1019
def is_defined?
  @defined
end
is_forward?() click to toggle source
# File lib/ridl/node.rb, line 1023
def is_forward?
  not @defined
end
is_local?() click to toggle source
# File lib/ridl/node.rb, line 1011
def is_local?
  @local
end
is_pseudo?() click to toggle source
# File lib/ridl/node.rb, line 1015
def is_pseudo?
  @pseudo
end
marshal_dump() click to toggle source
Calls superclass method IDL::AST::Node#marshal_dump
# File lib/ridl/node.rb, line 979
def marshal_dump
  super() << @bases << @resolved_bases << @defined << @abstract << @local << @pseudo << @idltype
end
marshal_load(vars) click to toggle source
Calls superclass method IDL::AST::Node#marshal_load
# File lib/ridl/node.rb, line 983
def marshal_load(vars)
  @idltype = vars.pop
  @pseudo = vars.pop
  @local = vars.pop
  @abstract = vars.pop
  @defined = vars.pop
  @resolved_bases = vars.pop
  @bases = vars.pop
  super(vars)
end
operations(include_bases = false, traversed = nil) click to toggle source
# File lib/ridl/node.rb, line 1084
def operations(include_bases = false, traversed = nil)
  ops = @children.find_all { |c| c.is_a?(IDL::AST::Operation) }
  ops.concat(base_operations(traversed || [])) if include_bases
  ops
end
redefine(node, params) click to toggle source
# File lib/ridl/node.rb, line 1096
def redefine(node, params)
  if node.enclosure == self
    case node
    when IDL::AST::Struct, IDL::AST::Union
      if node.is_defined?
        raise "#{node.typename} \"#{node.name}\" is already defined."
      end

      node.annotations.concat(params[:annotations])

      _new_node = node.class.new(node.name, self, params)
      _new_node.annotations.concat(node.annotations)
      _new_node.prefix = node.prefix
      _new_node.instance_variable_set(:@repo_ver, node.instance_variable_get(:@repo_ver))
      _new_node.instance_variable_set(:@repo_id, node.instance_variable_get(:@repo_id))

      node.switchtype = params[:switchtype] if node.is_a?(IDL::AST::Union)

      @children << _new_node
      # replace forward node registration
      node.enclosure.undo_introduction(node)
      introduce(_new_node)

      return _new_node
    else
      raise "#{node.typename} \"#{node.name}\" is already defined."
    end
  end

  case node
  when IDL::AST::Operation, IDL::AST::Attribute
    raise "#{node.typename} '#{node.scoped_lm_name}' cannot be overridden."
  else
    newnode = node.class.new(node.name, self, params)
    newnode.annotations.concat(params[:annotations])
    introduce(newnode)
    @children << newnode # add overriding child
    return newnode
  end
end

Protected Instance Methods

concrete_bases(instantiation_context) click to toggle source
# File lib/ridl/node.rb, line 1139
def concrete_bases(instantiation_context)
  # collect all bases and resolve any template param types
  @bases.collect do |base|
    IDL::AST::TemplateParam.concrete_param(instantiation_context, base)
  end
end
resolved_bases() click to toggle source
# File lib/ridl/node.rb, line 1146
def resolved_bases
  @resolved_bases
end