class EasySwig::ApiClass
Attributes
api_attributes[RW]
api_enums[RW]
api_innerclasses[RW]
api_methods[RW]
friend_support[RW]
group[RW]
ignored_attributes[RW]
ignored_enums[RW]
ignored_innerclasses[RW]
ignored_methods[RW]
match_subclasses[RW]
match_superclasses[RW]
nested_support[RW]
wrap_attributes[RW]
wrap_enums[RW]
wrap_innerclasses[RW]
wrap_methods[RW]
Public Class Methods
new(hash)
click to toggle source
Calls superclass method
# File lib/apinodes/api_class.rb, line 23 def initialize(hash) super(hash) @lookup_cache = {} @api_methods=[] @api_attributes=[] @api_innerclasses=[] @api_enums=[] @ignored_methods=[] @ignored_attributes=[] @ignored_innerclasses=[] @ignored_enums=[] @director=false end
Public Instance Methods
_lookup_node(type)
click to toggle source
# File lib/apinodes/api_class.rb, line 132 def _lookup_node(type) # TODO use lookup methods of Doxyparser and avoid selects return Doxyparser::Type.new({ name: type.basename, dir: ""}) if is_primitive?(type.basename) return type if is_std?(type.basename) return @wrapped_node if type.basename == @basename expanded_type = expand_typedefs(type) if expanded_type != type looked_up_type = lookup_node(expanded_type) return expanded_type if looked_up_type.nil? # TODO why? looked_up = expanded_type.name.gsub(expanded_type.escaped_name, looked_up_type.escaped_name) return Doxyparser::Type.new({ name: looked_up, dir: ""}) end innerclass = innerclasses.select { |ic| ic.basename == type.basename } unless innerclass.empty? if type.template? new_name = type.escaped_name.gsub(type.basename, innerclass[0].name) return Doxyparser::Type.new({ name: new_name, dir: innerclass[0].dir}) end return innerclass[0] end enum = enums.select { |ie| ie.basename == type.basename } return enum[0] unless enum.empty? if node_type == 'innerclass' sibling = parent.innerclasses.select { |c| c.basename == type.basename } else siblings = parent.classes + parent.structs sibling = siblings.select { |c| c.basename == type.basename } end unless sibling.empty? if type.template? new_name = type.escaped_name.gsub(type.basename, sibling[0].name) return Doxyparser::Type.new({ name: new_name, dir: sibling[0].dir}) end return sibling[0] end parent_enum = parent.enums.select { |e| e.basename == type.basename } return parent_enum[0] unless parent_enum.empty? if node_type == 'innerclass' return parent.lookup_node(type) else puts "Type '" + type.basename+ "' not found in class '" + @wrapped_node.name + "'\n-> Function or variable will be ignored." return nil end end
api_nodes()
click to toggle source
# File lib/apinodes/api_class.rb, line 37 def api_nodes [self] end
assoc_attributes()
click to toggle source
# File lib/apinodes/api_class.rb, line 70 def assoc_attributes all_attributes = @wrapped_node.attributes + @wrapped_node.attributes('public', 'static') ign_attributes = @ignored_attributes.map{|i| i.basename} if @wrap_attributes all_attributes.each { |a| if not ign_attributes.include?(a.basename) hash = {'features' => @features, 'node_type' => 'attribute', 'parent' => self, 'basename' => a.basename } @api_attributes << ApiAttribute.new(hash).assoc_with_node(a) end } else assoc_members(all_attributes, @api_attributes, @ignored_attributes) end end
assoc_enums()
click to toggle source
# File lib/apinodes/api_class.rb, line 108 def assoc_enums all_enums = @wrapped_node.enums ign_enums = @ignored_enums.map{ |i| i.basename } if @wrap_enums all_enums.each { |e| if !ign_enums.include?(e.basename) hash = {'features' => @features, 'node_type' => 'enum', 'parent' => self, 'basename' => e.basename } @api_enums << ApiEnum.new(hash).assoc_with_node(e) end } else assoc_members(all_enums, @api_enums, @ignored_enums) end self end
assoc_innerclasses()
click to toggle source
# File lib/apinodes/api_class.rb, line 85 def assoc_innerclasses all_innerclasses = @wrapped_node.innerclasses ign_innerclasses = @ignored_innerclasses.map{|i| i.basename} if @wrap_innerclasses all_innerclasses.each { |c| if !ign_innerclasses.include?(c.basename) hash = {'wrap_methods' => 'x', 'wrap_attributes' => 'x', 'wrap_enums' => 'x', 'wrap_innerclasses' => 'x', 'node_type' => 'innerclass', 'nested_support' => @nested_support, 'features' => @features, 'parent' => self, 'basename' => c.basename } @api_innerclasses << ApiClass.new(hash).assoc_with_node(c) end } else assoc_members(all_innerclasses, @api_innerclasses, @ignored_innerclasses) end end
assoc_methods()
click to toggle source
# File lib/apinodes/api_class.rb, line 54 def assoc_methods all_methods = @wrapped_node.methods + @wrapped_node.methods('public', 'static', nil) all_methods.reject!{ |f| f.basename == f.basename.upcase } ign_methods = @ignored_methods.map{|i| i.basename} if @wrap_methods all_methods.each { |m| if not ign_methods.include?(m.basename) hash = {'features' => @features, 'node_type' => 'method', 'parent' => self, 'basename' => m.basename } @api_methods << ApiMethod.new(hash).assoc_with_node(m) end } else assoc_functions(all_methods, @api_methods, @ignored_methods) end end
assoc_with_node(clazz)
click to toggle source
Calls superclass method
# File lib/apinodes/api_class.rb, line 46 def assoc_with_node(clazz) super(clazz) assoc_methods assoc_attributes assoc_innerclasses assoc_enums end
expand_typedefs(type)
click to toggle source
# File lib/apinodes/api_class.rb, line 176 def expand_typedefs(type) typedef = visible_typedefs.select { |t| t.basename == type.basename } # TODO use Doxyparser, avoid selects return type if typedef.empty? new_type = typedef[0].type.dup new_type.name = type.name.gsub(type.escaped_name, new_type.name) expand_typedefs(new_type) end
file()
click to toggle source
# File lib/apinodes/api_class.rb, line 41 def file return wrapped_node.file if node_type != 'innerclass' return parent.file end
included_in_files(typedef, files)
click to toggle source
# File lib/apinodes/api_class.rb, line 197 def included_in_files(typedef, files) ## TODO Optimize this files.any? { |file| ::File.basename(typedef.location) =~ %r{#{file.basename}:\d+$} } end
is_enum_or_innerclass?(target_name)
click to toggle source
# File lib/apinodes/api_class.rb, line 203 def is_enum_or_innerclass?(target_name) (innerclasses + enums).any?{ |c| c.basename == target_name} end
lookup_node(type)
click to toggle source
# File lib/apinodes/api_class.rb, line 124 def lookup_node(type) cached = @lookup_cache[type.escaped_name] return cached if cached looked_up = _lookup_node(type) @lookup_cache[type.escaped_name] = looked_up looked_up end
visible_typedefs()
click to toggle source
# File lib/apinodes/api_class.rb, line 184 def visible_typedefs if node_type == 'innerclass' return typedefs(:all) end namespace = @parent files_included = file.files_included ns_typedefs = [] if namespace.nil? ns_typedefs ||= namespace.typedefs.select { |typedef| included_in_files(typedef, [file, *files_included]) } typedefs(:all) + file.typedefs + ns_typedefs end