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