def has_hdf5_scheme(self, c):
"""True iif the class c has a static method std::string hdf5_scheme()"""
keep = lambda m : CL.is_public(m)
for m in CL.get_methods(c, True, keep):
if m.spelling == "hdf5_scheme" and m.is_static_method() and ('string' in m.result_type.spelling) and len(list(CL.get_params(m))) == 0:
return True
return False
def generate_desc_file(self, output_filename, verbose=True):
""" Makes the desc file"""
# First treat the parameter class if any (classes passed by dictionnary that MUST be converted)
param_cls_list = list(self.get_all_param_classes())
# Precompute
self.all_enums = list(self.all_enums_gen())
self.all_classes = list(self.all_classes_gen())
self.all_functions = list(self.all_functions_gen())
self.param_cls_list = param_cls_list
# checks
for c in param_cls_list:
for m in CL.get_members(c, True):
assert CL.is_public(
m
), "Parameter class : all members must be public. %s::%s is not" % (
c.spelling, m.spelling)
# analyse the modules and converters that need to be added
print "Analysing dependencies"
types_being_wrapped_or_converted = param_cls_list + self.all_classes + self.all_enums
import_list, converters_list = self.DE(
self.get_all_params_ret_type(param_cls_list),
types_being_wrapped_or_converted)
# Reporting
if self.all_classes:
print "Wrapping classes:"
for c in self.all_classes:
print " ", c.spelling
if self.all_enums:
print "Wrapping enums:"
for c in self.all_enums:
print " ", c.spelling
if self.all_functions:
print "Wrapping functions:"
for c in self.all_functions:
print " ", c.spelling
if param_cls_list:
print "Generating converters for :"
for c in param_cls_list:
print " ", c.spelling
# Render mako
print "Generating " + output_filename
tpl = Template(filename=util.script_path() + '/mako/desc.py',
strict_undefined=True)
rendered = tpl.render(W=self,
CL=CL,
doc=doc,
util=util,
import_list=import_list,
converters_list=converters_list,
using_list=list(self.namespaces) +
list(self.namespace_to_factor))
open(output_filename,
"w").write(util.clean_end_and_while_char(rendered))
def has_hdf5_scheme(self, c):
"""True iif the class c has a static method std::string hdf5_scheme()"""
keep = lambda m: CL.is_public(m)
for m in CL.get_methods(c, True, keep):
if m.spelling == "hdf5_scheme" and m.is_static_method() and (
'string' in m.result_type.spelling) and len(
list(CL.get_params(m))) == 0:
return True
return False
def generate_desc_file(self, output_filename, verbose = True):
""" Makes the desc file"""
# First treat the parameter class if any (classes passed by dictionnary that MUST be converted)
param_cls_list = list(self.get_all_param_classes())
for c in param_cls_list :
open('parameters_%s.rst'%c.spelling, 'w').write(doc.doc_param_dict_format(CL.get_members(c, True)))
# Precompute
self.all_enums = list(self.all_enums_gen())
self.all_classes = list(self.all_classes_gen())
self.all_functions = list(self.all_functions_gen())
self.param_cls_list = param_cls_list
# checks
for c in param_cls_list:
for m in CL.get_members(c, True):
assert CL.is_public(m), "Parameter class : all members must be public. %s::%s is not"%(c.spelling, m.spelling)
# analyse the modules and converters that need to be added
print "Analysing dependencies"
types_being_wrapped_or_converted = param_cls_list + self.all_classes + self.all_enums
import_list, converters_list = self.DE(self.get_all_params_ret_type(param_cls_list), types_being_wrapped_or_converted)
if any(map(self.has_hdf5_scheme, self.all_classes)):
converters_list.append("triqs/cpp2py_converters/h5.hpp")
# Reporting
if self.all_classes:
print "Wrapping classes:"
for c in self.all_classes:
print " ", c.spelling
if self.all_enums:
print "Wrapping enums:"
for c in self.all_enums:
print " ", c.spelling
if self.all_functions:
print "Wrapping functions:"
for c in self.all_functions:
print " ", c.spelling
if param_cls_list:
print "Generating converters for :"
for c in param_cls_list:
print " ", c.spelling
# Render mako
print "Generating " + output_filename
tpl = Template(filename= util.script_path() + '/mako/desc.py', strict_undefined = True)
rendered = tpl.render(W = self, CL = CL, doc = doc, util = util,
import_list = import_list, converters_list = converters_list, using_list = list(self.namespaces) + list(self.namespace_to_factor))
open(output_filename, "w").write(util.clean_end_and_while_char(rendered))
def get_public_methods(self, c):
"""
Parameters
-----------
c: AST node
a cursor to a class
Returns
--------
A list of cursors to the methods
return : a tuple (proplist, methodlist) where proplist : a list of property_ and methodlist : the others methods
"""
keep = lambda m : CL.is_public(m) and not CL.is_template(m) and not ("ignore_in_python" in CL.get_annotations(m)) and not m.spelling.startswith('operator')
return CL.get_methods(c, True, keep)
def get_public_methods(self, c):
"""
Parameters
-----------
c: AST node
a cursor to a class
Returns
--------
A list of cursors to the methods
return : a tuple (proplist, methodlist) where proplist : a list of property_ and methodlist : the others methods
"""
keep = lambda m: CL.is_public(m) and not m.spelling.startswith(
'operator')
return CL.get_methods(c, True, keep)
def get_public_methods(self, c):
"""
Parameters
-----------
c: AST node
a cursor to a class
Returns
--------
A list of cursors to the methods
return : a tuple (proplist, methodlist) where proplist : a list of property_ and methodlist : the others methods
"""
keep = lambda m: CL.is_public(m) and not CL.is_template(
m) and not ("ignore_in_python" in CL.get_annotations(m)
) and not (m.spelling.startswith('operator') and not m.
spelling == "operator()")
return CL.get_methods(c, True, keep)
