Module: EasySwig::GeneratorUtil

Includes:
Query, Util
Included in:
ClassGenerator, HFileGenerator, NamespaceGenerator
Defined in:
lib/generators/generator_util.rb

Instance Method Summary collapse

Methods included from Query

#anonymous_enum?, #get_reference_type, #is_operator?, #is_template?, #is_template_param?, #lookup_typename, #method_has_blacklisted_types?, #name_for_friend, #name_for_operator, #name_for_template, #nested_typenames_for, #no_public_constructors?, #no_public_destructors?, #type_is_blacklisted?, #typename_is_blacklisted?

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

Instance Method Details

#_process_type(type, klass) ⇒ Object

Raises:

  • (ArgumentError) 


66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/generators/generator_util.rb', line 66

def _process_type(type, klass)
	raise ArgumentError if type.nil?
	cached_type = @types[type.escaped_name]
	return cached_type unless cached_type.nil?
	# Don't instantiate templates for functions with type params
	return nil if is_template_param?(type.escaped_name, klass)
	
	typename = type.escaped_name.dup
	if is_template?(typename)
	 	nested_typenames_for(typename).each{ |t|
	 		nested_type = Doxyparser::Type.new({ name: t, dir: ""})
    	typename.gsub!(t, _process_type(nested_type, klass))
  	}
  	expanded_typename = typename 
  else
  	lookedup = lookup_typename(type, klass)  
  	raise ArgumentError if lookedup.nil?  	
  	if is_template?(lookedup) # Repeat recursively
  		lookedup_escaped = escape_const_ref_ptr(lookedup)
  		lookedup_type = Doxyparser::Type.new({ name: lookedup_escaped, dir: ""})
  		expanded_typename = lookedup.gsub!(lookedup_escaped, _process_type(lookedup_type, klass))
  	else
  		expanded_typename = lookedup
  	end
	end
	escaped_typename = escape_const_ref_ptr(expanded_typename)
	unless @all_types.has_key?(escaped_typename)
	  @all_types[escaped_typename] = 1
    @types[type.name] = escaped_typename
  end
			return expanded_typename	
end

#enum_snippet(enum) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/generators/generator_util.rb', line 109

def enum_snippet(enum)
  snippet = "\n\t\tenum #{enum.basename} {"
  aux = ''
  enum.values.each { |v|
    aux << "\n\t\t\t#{v.basename}" 
    if v.initializer
    	aux << " = #{v.initializer}," 
    else
    	aux << ","
    end
  }
  aux.chomp! ','
  snippet << aux
  snippet << "\n\t\t};\n"
  snippet
end

#ignore_enum_values_snippet(enum) ⇒ Object 



126
127
128
129
130
131
132
 
# File 'lib/generators/generator_util.rb', line 126

def ignore_enum_values_snippet(enum)
  snippet = ""
  enum.values.each { |v|
    snippet << "%rename($ignore) #{enum.parent.name}::#{v.basename};\n"
  }
  snippet
end

#nested_workaround(innerclass) ⇒ Object

Innerclasses



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/generators/generator_util.rb', line 6

def nested_workaround(innerclass)	# Innerclasses    	
  return '' if innerclass.abstract?
  return '' if no_public_constructors?(innerclass) || no_public_destructors?(innerclass)
  return '' if @all_innerclasses[innerclass.target_name]
  
  namespace = @api_class.parent
	siblings = namespace.classes + namespace.structs
  return '' if siblings.any?{ |c| c.basename == innerclass.basename }
	swig_file  = ''
	own_typedefs = {}
  
  swig_file << "namespace #{namespace.name} {\n"
  swig_file << "\tclass #{innerclass.target_name} {\n"
  swig_file << "\t\tpublic:\n"
  innerclass.api_attributes.each { |attr| 
  	typename = attr.type.name
  	if is_template?(typename)
  		typename = typename.gsub('>::type', '>') # TODO only for Ogre
  	end
   	swig_file << "\t\t#{attr.static.to_s} #{typename} #{attr.basename};\n"
  }
  innerclass.api_methods.each { |meth|
  	broken = false
   type_typename = meth.type.name
  	if is_template?(type_typename)
  		type_typename = type_typename.gsub('>::type', '>') # TODO only for Ogre
  	end
    param_typenames = ""
   n = 1
    meth.params.map{ |p|
    	typename = p.type.name
  		if is_template?(typename)
  			typename = typename.gsub('>::type', '>') # TODO only for Ogre
  		end
  		param_typenames << " #{typename} arg#{n},"
  		n += 1
    }
    next if broken
    swig_file << "\t\t#{meth.static.to_s} #{type_typename} #{meth.basename}(#{param_typenames.chop});\n"
  }
  innerclass.api_enums.each { |enum|
    swig_file << enum_snippet(enum)
  }
  @all_innerclasses[innerclass.target_name] = 1
  swig_file << "\t};\n}\n"
  swig_file << "%rename(#{innerclass.target_name}) #{innerclass.basename};\n"
  swig_file << "%nestedworkaround #{@api_class.name}::#{innerclass.basename};\n"
  swig_file << "%{\nnamespace #{namespace.name} {\n"
  swig_file << "\ttypedef #{@api_class.name}::#{innerclass.basename} #{innerclass.target_name};\n"
  swig_file << "}\n%}\n"
  swig_file
end

#process_type(type, klass) ⇒ Object 



59
60
61
62
63
64
 
# File 'lib/generators/generator_util.rb', line 59

def process_type(type, klass)
	new_type = type.dup
	new_type.name = type.escaped_name
	new_typename = _process_type(new_type, klass)
	type.name = type.name.gsub(type.escaped_name, new_typename)
end

#template_snippet(typename, expanded) ⇒ Object 



99
100
101
102
103
104
105
106
107
 
# File 'lib/generators/generator_util.rb', line 99

def template_snippet(typename, expanded)
	swig_file = ''
 expanded = expanded.gsub('>::type', '>') # TODO only for Ogre
	if is_template?(expanded)
		typename = name_for_template(expanded) if is_template?(typename) # TODO reconsider
  	swig_file << "%template(#{typename}) #{expanded};\n"
  end
  swig_file
end