class IDL::AST::Derivable

Public Instance Methods

has_ancestor?(n) click to toggle source
# File lib/ridl/node.rb, line 900
def has_ancestor?(n)
  self.has_base?(n) || resolved_bases.any? { |b| b.has_ancestor?(n) }
end
search_self(_name) click to toggle source
# File lib/ridl/node.rb, line 894
def search_self(_name)
  node = search_self_before_derived(_name)
  node = search_ancestors(_name) if node.nil?
  node
end
Also aliased as: search_self_before_derived
search_self_before_derived(_name)
Alias for: search_self

Protected Instance Methods

base_attributes(traversed) click to toggle source

recursively collect attributes from bases

# File lib/ridl/node.rb, line 951
def base_attributes(traversed)
  traversed.push self
  atts = []
  resolved_bases.each do |base|
    base = base.idltype.resolved_type.node if base.is_a?(IDL::AST::Typedef)
    atts.concat(base.attributes(true, traversed)) unless traversed.include?(base)
  end
  atts
end
base_operations(traversed) click to toggle source

recursively collect operations from bases

# File lib/ridl/node.rb, line 940
def base_operations(traversed)
  traversed.push self
  ops = []
  resolved_bases.each do |base|
    base = base.idltype.resolved_type.node if base.is_a?(IDL::AST::Typedef)
    ops.concat(base.operations(true, traversed)) unless traversed.include?(base)
  end
  ops
end
each_ancestors(visited = []) { |p| ... } click to toggle source
# File lib/ridl/node.rb, line 910
def each_ancestors(visited = [], &block)
  resolved_bases.each do |p|
    next if visited.include? p

    yield(p)
    visited.push p
    p.each_ancestors(visited, &block)
  end
end
resolved_bases() click to toggle source
# File lib/ridl/node.rb, line 906
def resolved_bases
  []
end
search_ancestors(_name) click to toggle source

search inherited interfaces.

# File lib/ridl/node.rb, line 921
   def search_ancestors(_name)
     results = []
     self.each_ancestors do |interface|
       node = interface.search_self(_name)
       results.push(node) unless node.nil?
     end
     if results.size > 1
       # check if the matched name resulted in multiple different nodes or all the same
       r_one = results.shift
       unless results.all? { |r| r_one == r || (r_one.class == r.class && r_one.scoped_name == r.scoped_name) }
         s = results.inject([r_one]) { |l, r| l << r unless l.include?(r)
l }.collect { |n| n.scoped_name }.join(", ")
         raise "\"#{_name}\" is ambiguous. " + s
       end
     end
     results.first
   end