Class: EasySwig::ApiClass

Inherits:
ApiNode
  • Object
show all
Defined in:
lib/apinodes/api_class.rb

Instance Attribute Summary collapse

Attributes inherited from ApiNode

#basename, #directory, #features, #header_file, #ignore, #match, #node_type, #parent, #target_name, #wrapped_node

Instance Method Summary collapse

Methods inherited from ApiNode

#assoc_functions, #assoc_members, #fullname, #method_missing, #to_str

Methods included from Util

#del_prefix_class, #escape_all, #escape_const_ref_ptr, #escape_template, #gen_dir, #home_dir, #is_primitive?, #is_std?, #lib_dir, #logs_dir, #output_dir, #read_file, #rename_files, #swig_dir, #write_file

Constructor Details

#initialize(hash) ⇒ ApiClass

Returns a new instance of ApiClass.



23
24
25
26
27
28
29
30
31
32
33
34
35
 
# 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

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class EasySwig::ApiNode

Instance Attribute Details

#api_attributes ⇒ Object

Returns the value of attribute api_attributes.



6
7
8
 
# File 'lib/apinodes/api_class.rb', line 6

def api_attributes
  @api_attributes
end

#api_enums ⇒ Object

Returns the value of attribute api_enums.



8
9
10
 
# File 'lib/apinodes/api_class.rb', line 8

def api_enums
  @api_enums
end

#api_innerclasses ⇒ Object

Returns the value of attribute api_innerclasses.



7
8
9
 
# File 'lib/apinodes/api_class.rb', line 7

def api_innerclasses
  @api_innerclasses
end

#api_methods ⇒ Object

Returns the value of attribute api_methods.



5
6
7
 
# File 'lib/apinodes/api_class.rb', line 5

def api_methods
  @api_methods
end

#friend_support ⇒ Object

Returns the value of attribute friend_support.



21
22
23
 
# File 'lib/apinodes/api_class.rb', line 21

def friend_support
  @friend_support
end

#group ⇒ Object

Returns the value of attribute group.



15
16
17
 
# File 'lib/apinodes/api_class.rb', line 15

def group
  @group
end

#ignored_attributes ⇒ Object

Returns the value of attribute ignored_attributes.



10
11
12
 
# File 'lib/apinodes/api_class.rb', line 10

def ignored_attributes
  @ignored_attributes
end

#ignored_enums ⇒ Object

Returns the value of attribute ignored_enums.



12
13
14
 
# File 'lib/apinodes/api_class.rb', line 12

def ignored_enums
  @ignored_enums
end

#ignored_innerclasses ⇒ Object

Returns the value of attribute ignored_innerclasses.



11
12
13
 
# File 'lib/apinodes/api_class.rb', line 11

def ignored_innerclasses
  @ignored_innerclasses
end

#ignored_methods ⇒ Object

Returns the value of attribute ignored_methods.



9
10
11
 
# File 'lib/apinodes/api_class.rb', line 9

def ignored_methods
  @ignored_methods
end

#match_subclasses ⇒ Object

Returns the value of attribute match_subclasses.



13
14
15
 
# File 'lib/apinodes/api_class.rb', line 13

def match_subclasses
  @match_subclasses
end

#match_superclasses ⇒ Object

Returns the value of attribute match_superclasses.



14
15
16
 
# File 'lib/apinodes/api_class.rb', line 14

def match_superclasses
  @match_superclasses
end

#nested_support ⇒ Object

Returns the value of attribute nested_support.



20
21
22
 
# File 'lib/apinodes/api_class.rb', line 20

def nested_support
  @nested_support
end

#wrap_attributes ⇒ Object

Returns the value of attribute wrap_attributes.



19
20
21
 
# File 'lib/apinodes/api_class.rb', line 19

def wrap_attributes
  @wrap_attributes
end

#wrap_enums ⇒ Object

Returns the value of attribute wrap_enums.



18
19
20
 
# File 'lib/apinodes/api_class.rb', line 18

def wrap_enums
  @wrap_enums
end

#wrap_innerclasses ⇒ Object

Returns the value of attribute wrap_innerclasses.



16
17
18
 
# File 'lib/apinodes/api_class.rb', line 16

def wrap_innerclasses
  @wrap_innerclasses
end

#wrap_methods ⇒ Object

Returns the value of attribute wrap_methods.



17
18
19
 
# File 'lib/apinodes/api_class.rb', line 17

def wrap_methods
  @wrap_methods
end

Instance Method Details

#_lookup_node(type) ⇒ Object

TODO use lookup methods of Doxyparser and avoid selects



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# 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 ⇒ Object 



37
38
39
 
# File 'lib/apinodes/api_class.rb', line 37

def api_nodes
  [self]
end

#assoc_attributes ⇒ Object 



70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# 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 ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# 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 ⇒ Object 



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# 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 ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# 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) ⇒ Object 



46
47
48
49
50
51
52
 
# 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) ⇒ Object 



176
177
178
179
180
181
182
 
# 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 ⇒ Object 



41
42
43
44
 
# 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) ⇒ Object

TODO Optimize this



197
198
199
200
201
 
# 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) ⇒ Boolean

Returns:

  • (Boolean) 


203
204
205
 
# 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) ⇒ Object 



124
125
126
127
128
129
130
 
# 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 ⇒ Object 



184
185
186
187
188
189
190
191
192
193
194
195
 
# 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