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