Source code for xdress.stlwrap
"""Generates cython wrapper classes and converter functions for standard library
containters to the associated python types.
This module is available as an xdress plugin by the name ``xdress.stlwrap``.
:author: Anthony Scopatz <scopatz@gmail.com>
C++ STL Wrapper API
===================
"""
from __future__ import print_function
import os
import sys
import pprint
from .utils import newoverwrite, newcopyover, ensuredirs, indent, indentstr, \
RunControl, NotSpecified
from .plugins import Plugin
from .typesystem import TypeSystem
if sys.version_info[0] >= 3:
basestring = str
testvals = {
'char': ["m", "e", "t", "l"],
'str': ["Aha", "Take", "Me", "On"],
'int32': [1, 42, -65, 18],
'bool': [True, False, False, True],
'uint32': [1, 65, 4294967295, 42],
'float32': [1.0, 42.42, -65.5555, 18],
'float64': [1.0, 42.42, -65.5555, 18],
'complex128': [1.0, 42+42j, -65.55-1j, 0.18j],
}
for t, tval in list(testvals.items()):
testvals[('set', t, 0)] = list(map(set, [tval, tval[::-1], tval[::2]*2,
tval[1::2]*2]))
testvals[('vector', t, 0)] = [tval, tval[::-1], tval[::2]*2, tval[1::2]*2]
items = list(testvals.items())
for t, tval in items:
tval = list(map(tuple, tval)) if isinstance(tval[0], list) else tval
tval = list(map(frozenset, tval)) if isinstance(tval[0], set) else tval
for u, uval in items:
testvals[('map', t, u, 0)] = [dict(zip(tval, uval)),
dict(zip(tval[::-1], uval[::-1])),
dict(zip(tval[::2]*2, uval[::2]*2)),
dict(zip(tval[1::2]*2, uval[1::2]*2))]
del t, u, tval, uval, items
#
# Sets
#
_pyxset = '''# Set{clsname}
cdef class _SetIter{clsname}(object):
cdef void init(self, cpp_set[{ctype}] * set_ptr):
cdef cpp_set[{ctype}].iterator * itn = <cpp_set[{ctype}].iterator *> malloc(sizeof(set_ptr.begin()))
itn[0] = set_ptr.begin()
self.iter_now = itn
cdef cpp_set[{ctype}].iterator * ite = <cpp_set[{ctype}].iterator *> malloc(sizeof(set_ptr.end()))
ite[0] = set_ptr.end()
self.iter_end = ite
def __dealloc__(self):
free(self.iter_now)
free(self.iter_end)
def __iter__(self):
return self
def __next__(self):
cdef cpp_set[{ctype}].iterator inow = deref(self.iter_now)
cdef cpp_set[{ctype}].iterator iend = deref(self.iter_end)
{c2pydecl.indent8}
if inow != iend:
{c2pybody.indent12}
pyval = {c2pyrtn}
else:
raise StopIteration
inc(deref(self.iter_now))
return pyval
cdef class _Set{clsname}:
def __cinit__(self, new_set=True, bint free_set=True):
cdef {ctype} s
cdef cpp_set[{ctype}] * set_ptr
{py2cdecl.indent8}
# Decide how to init set, if at all
if isinstance(new_set, _Set{clsname}):
self.set_ptr = (<_Set{clsname}> new_set).set_ptr
elif isinstance(new_set, np.generic) and np.PyArray_DescrFromScalar(new_set).type_num == {set_cython_nptype}:
# scalars are copies, sadly not views, so we need to re-copy
if self.set_ptr == NULL:
self.set_ptr = new cpp_set[{ctype}]()
np.PyArray_ScalarAsCtype(new_set, &set_ptr)
self.set_ptr[0] = set_ptr[0]
elif hasattr(new_set, '__iter__') or \\
(hasattr(new_set, '__len__') and
hasattr(new_set, '__getitem__')):
self.set_ptr = new cpp_set[{ctype}]()
for value in new_set:
{py2cbody.indent16}
s = {py2crtn}
self.set_ptr.insert(s)
elif bool(new_set):
self.set_ptr = new cpp_set[{ctype}]()
# Store free_set
self._free_set = free_set
def __dealloc__(self):
if self._free_set:
del self.set_ptr
def __contains__(self, value):
cdef {ctype} s
{py2cdecl.indent8}
if {isinst}:
{py2cbody.indent12}
s = {py2crtn}
else:
return False
if 0 < self.set_ptr.count(s):
return True
else:
return False
def __len__(self):
return self.set_ptr.size()
def __iter__(self):
cdef _SetIter{clsname} si = _SetIter{clsname}()
si.init(self.set_ptr)
return si
def add(self, value):
cdef {ctype} v
{py2cdecl.indent8}
{py2cbody.indent8}
v = {py2crtn}
self.set_ptr.insert(v)
return
def discard(self, value):
cdef {ctype} v
{py2cdecl.indent8}
if value in self:
{py2cbody.indent12}
v = {py2crtn}
self.set_ptr.erase(v)
return
class Set{clsname}(_Set{clsname}, collections.Set):
"""Wrapper class for C++ standard library sets of type <{humname}>.
Provides set like interface on the Python level.
Parameters
----------
new_set : bool or set-like
Boolean on whether to make a new set or not, or set-like object
with values which are castable to the appropriate type.
free_set : bool
Flag for whether the pointer to the C++ set should be deallocated
when the wrapper is dereferenced.
"""
def __str__(self):
return self.__repr__()
def __repr__(self):
return "set([" + ", ".join([repr(i) for i in self]) + "])"
'''
[docs]def genpyx_set(t, ts):
"""Returns the pyx snippet for a set of type t."""
t = ts.canon(t)
kw = dict(clsname=ts.cython_classname(t)[1], humname=ts.humanname(t)[1],
ctype=ts.cython_ctype(t), pytype=ts.cython_pytype(t),
cytype=ts.cython_cytype(t),)
fpt = ts.from_pytypes[t]
kw['isinst'] = " or ".join(["isinstance(value, {0})".format(x) for x in fpt])
c2pykeys = ['c2pydecl', 'c2pybody', 'c2pyrtn']
c2py = ts.cython_c2py('inow', t, existing_name="deref(inow)", cached=False)
kw.update([(k, indentstr(v or '')) for k, v in zip(c2pykeys, c2py)])
py2ckeys = ['py2cdecl', 'py2cbody', 'py2crtn']
py2c = ts.cython_py2c("value", t)
kw.update([(k, indentstr(v or '')) for k, v in zip(py2ckeys, py2c)])
kw['set_cython_nptype'] = ts.cython_nptype(('set', t, 0))
return _pyxset.format(**kw)
_pxdset = """# Set{clsname}
cdef class _SetIter{clsname}(object):
cdef cpp_set[{ctype}].iterator * iter_now
cdef cpp_set[{ctype}].iterator * iter_end
cdef void init(_SetIter{clsname}, cpp_set[{ctype}] *)
cdef class _Set{clsname}:
cdef cpp_set[{ctype}] * set_ptr
cdef public bint _free_set
"""
[docs]def genpxd_set(t, ts):
"""Returns the pxd snippet for a set of type t."""
return _pxdset.format(clsname=ts.cython_classname(t)[1], ctype=ts.cython_ctype(t))
_testset = """# Set{clsname}
def test_set_{fncname}():
s = {stlcontainers}.Set{clsname}()
s.add({0})
assert_true({0} in s)
assert_true({2} not in s)
s = {stlcontainers}.Set{clsname}([{0}, {1}, {2}])
assert_true({1} in s)
assert_true({3} not in s)
"""
[docs]def gentest_set(t, ts):
"""Returns the test snippet for a set of type t."""
t = ts.canon(t)
if t not in testvals:
return ""
return _testset.format(*[repr(i) for i in testvals[t]],
clsname=ts.cython_classname(t)[1],
fncname=ts.cython_functionname(t)[1],
stlcontainers=ts.stlcontainers)
#
# Maps
#
_pyxmap = '''# Map({tclsname}, {uclsname})
cdef class _MapIter{tclsname}{uclsname}(object):
cdef void init(self, cpp_map[{tctype}, {uctype}] * map_ptr):
cdef cpp_map[{tctype}, {uctype}].iterator * itn = <cpp_map[{tctype}, {uctype}].iterator *> malloc(sizeof(map_ptr.begin()))
itn[0] = map_ptr.begin()
self.iter_now = itn
cdef cpp_map[{tctype}, {uctype}].iterator * ite = <cpp_map[{tctype}, {uctype}].iterator *> malloc(sizeof(map_ptr.end()))
ite[0] = map_ptr.end()
self.iter_end = ite
def __dealloc__(self):
free(self.iter_now)
free(self.iter_end)
def __iter__(self):
return self
def __next__(self):
cdef cpp_map[{tctype}, {uctype}].iterator inow = deref(self.iter_now)
cdef cpp_map[{tctype}, {uctype}].iterator iend = deref(self.iter_end)
{tc2pydecl.indent8}
if inow != iend:
{tc2pybody.indent12}
pyval = {tc2pyrtn}
else:
raise StopIteration
inc(deref(self.iter_now))
return pyval
cdef class _Map{tclsname}{uclsname}:
def __cinit__(self, new_map=True, bint free_map=True):
cdef pair[{tctype}, {uctype}] item
cdef cpp_map[{tctype}, {uctype}] * map_ptr
{tpy2cdecl.indent8}
{upy2cdecl.indent8}
# Decide how to init map, if at all
if isinstance(new_map, _Map{tclsname}{uclsname}):
self.map_ptr = (<_Map{tclsname}{uclsname}> new_map).map_ptr
elif isinstance(new_map, np.generic) and np.PyArray_DescrFromScalar(new_map).type_num == {map_cython_nptype}:
# scalars are copies, sadly not views, so we need to re-copy
if self.map_ptr == NULL:
self.map_ptr = new cpp_map[{tctype}, {uctype}]()
np.PyArray_ScalarAsCtype(new_map, &map_ptr)
self.map_ptr[0] = map_ptr[0]
elif hasattr(new_map, 'items'):
self.map_ptr = new cpp_map[{tctype}, {uctype}]()
for key, value in new_map.items():
{tpy2cbody.indent16}
{upy2cbody.indent16}
item = pair[{tctype}, {uctype}]({tpy2crtn}, {upy2crtn})
self.map_ptr.insert(item)
elif hasattr(new_map, '__len__'):
self.map_ptr = new cpp_map[{tctype}, {uctype}]()
for key, value in new_map:
{tpy2cbody.indent16}
{upy2cbody.indent16}
item = pair[{tctype}, {uctype}]({tpy2crtn}, {upy2crtn})
self.map_ptr.insert(item)
elif bool(new_map):
self.map_ptr = new cpp_map[{tctype}, {uctype}]()
# Store free_map
self._free_map = free_map
def __dealloc__(self):
if self._free_map:
del self.map_ptr
def __contains__(self, key):
cdef {tctype} k
{tpy2cdecl.indent8}
if {tisnotinst}:
return False
{tpy2cbody.indent8}
k = {tpy2crtn}
if 0 < self.map_ptr.count(k):
return True
else:
return False
def __len__(self):
return self.map_ptr.size()
def __iter__(self):
cdef _MapIter{tclsname}{uclsname} mi = _MapIter{tclsname}{uclsname}()
mi.init(self.map_ptr)
return mi
def __getitem__(self, key):
cdef {tctype} k
cdef {uctype} v
{tpy2cdecl.indent8}
{uc2pydecl.indent8}
if {tisnotinst}:
raise TypeError("Only {thumname} keys are valid.")
{tpy2cbody.indent8}
k = {tpy2crtn}
if 0 < self.map_ptr.count(k):
v = deref(self.map_ptr)[k]
{uc2pybody.indent12}
return {uc2pyrtn}
else:
raise KeyError
def __setitem__(self, key, value):
{tpy2cdecl.indent8}
{upy2cdecl.indent8}
cdef pair[{tctype}, {uctype}] item
{tpy2cbody.indent8}
{upy2cbody.indent8}
item = pair[{tctype}, {uctype}]({tpy2crtn}, {upy2crtn})
if 0 < self.map_ptr.count({tpy2crtn}):
self.map_ptr.erase({tpy2crtn})
self.map_ptr.insert(item)
def __delitem__(self, key):
cdef {tctype} k
{tpy2cdecl.indent8}
if key in self:
{tpy2cbody.indent12}
k = {tpy2crtn}
self.map_ptr.erase(k)
class Map{tclsname}{uclsname}(_Map{tclsname}{uclsname}, collections.MutableMapping):
"""Wrapper class for C++ standard library maps of type <{thumname}, {uhumname}>.
Provides dictionary like interface on the Python level.
Parameters
----------
new_map : bool or dict-like
Boolean on whether to make a new map or not, or dict-like object
with keys and values which are castable to the appropriate type.
free_map : bool
Flag for whether the pointer to the C++ map should be deallocated
when the wrapper is dereferenced.
"""
def __str__(self):
return self.__repr__()
def __repr__(self):
return "{{" + ", ".join(["{{0}}: {{1}}".format(repr(key), repr(value)) for key, value in self.items()]) + "}}"
'''
[docs]def genpyx_map(t, u, ts):
"""Returns the pyx snippet for a map of type <t, u>."""
t = ts.canon(t)
u = ts.canon(u)
kw = dict(tclsname=ts.cython_classname(t)[1], uclsname=ts.cython_classname(u)[1],
thumname=ts.humanname(t)[1], uhumname=ts.humanname(u)[1],
tctype=ts.cython_ctype(t), uctype=ts.cython_ctype(u),
tpytype=ts.cython_pytype(t), upytype=ts.cython_pytype(u),
tcytype=ts.cython_cytype(t), ucytype=ts.cython_cytype(u),)
tisnotinst = ["not isinstance(key, {0})".format(x) for x in ts.from_pytypes[t]]
kw['tisnotinst'] = " and ".join(tisnotinst)
tc2pykeys = ['tc2pydecl', 'tc2pybody', 'tc2pyrtn']
tc2py = ts.cython_c2py('inow_first', t, existing_name="deref(inow).first",
cached=False)
kw.update([(k, indentstr(v or '')) for k, v in zip(tc2pykeys, tc2py)])
uc2pykeys = ['uc2pydecl', 'uc2pybody', 'uc2pyrtn']
uc2py = ts.cython_c2py("v", u, cached=False,
existing_name="deref(self.map_ptr)[k]")
kw.update([(k, indentstr(v or '')) for k, v in zip(uc2pykeys, uc2py)])
tpy2ckeys = ['tpy2cdecl', 'tpy2cbody', 'tpy2crtn']
tpy2c = ts.cython_py2c("key", t)
kw.update([(k, indentstr(v or '')) for k, v in zip(tpy2ckeys, tpy2c)])
upy2ckeys = ['upy2cdecl', 'upy2cbody', 'upy2crtn']
upy2c = ts.cython_py2c("value", u)
kw.update([(k, indentstr(v or '')) for k, v in zip(upy2ckeys, upy2c)])
kw['map_cython_nptype'] = ts.cython_nptype(('map', t, u, 0))
return _pyxmap.format(**kw)
_pxdmap = """# Map{tclsname}{uclsname}
cdef class _MapIter{tclsname}{uclsname}(object):
cdef cpp_map[{tctype}, {uctype}].iterator * iter_now
cdef cpp_map[{tctype}, {uctype}].iterator * iter_end
cdef void init(_MapIter{tclsname}{uclsname}, cpp_map[{tctype}, {uctype}] *)
cdef class _Map{tclsname}{uclsname}:
cdef cpp_map[{tctype}, {uctype}] * map_ptr
cdef public bint _free_map
"""
[docs]def genpxd_map(t, u, ts):
"""Returns the pxd snippet for a set of type t."""
t = ts.canon(t)
u = ts.canon(u)
return _pxdmap.format(tclsname=ts.cython_classname(t)[1],
uclsname=ts.cython_classname(u)[1],
thumname=ts.humanname(t)[1], uhumname=ts.humanname(u)[1],
tctype=ts.cython_ctype(t), uctype=ts.cython_ctype(u),)
_testmap = """# Map{tclsname}{uclsname}
def test_map_{tfncname}_{ufncname}():
m = {stlcontainers}.Map{tclsname}{uclsname}()
uismap = isinstance({5}, Mapping)
m[{0}] = {4}
m[{1}] = {5}
import pprint
pprint.pprint(m)
assert_equal(len(m), 2)
if uismap:
for key, value in m[{1}].items():
print(key, value, {5}[key])
if isinstance(value, np.ndarray):
assert{array}_equal(value, {5}[key])
else:
assert_equal(value, {5}[key])
else:
assert{array}_equal(m[{1}], {5})
m = {stlcontainers}.Map{tclsname}{uclsname}({{{2}: {6}, {3}: {7}}})
assert_equal(len(m), 2)
if uismap:
for key, value in m[{2}].items():
if isinstance(value, np.ndarray):
print(key, value, {6}[key])
assert{array}_equal(value, {6}[key])
else:
assert_equal(value, {6}[key])
else:
assert{array}_equal(m[{2}], {6})
n = {stlcontainers}.Map{tclsname}{uclsname}(m, False)
assert_equal(len(n), 2)
if uismap:
for key, value in m[{2}].items():
if isinstance(value, np.ndarray):
assert{array}_equal(value, {6}[key])
else:
assert_equal(value, {6}[key])
else:
assert{array}_equal(m[{2}], {6})
# points to the same underlying map
n[{1}] = {5}
if uismap:
for key, value in m[{1}].items():
if isinstance(value, np.ndarray):
assert{array}_equal(value, {5}[key])
else:
assert_equal(value, {5}[key])
else:
assert{array}_equal(m[{1}], {5})
"""
[docs]def gentest_map(t, u, ts):
"""Returns the test snippet for a map of type t."""
t = ts.canon(t)
u = ts.canon(u)
if t not in testvals or u not in testvals:
return ""
ulowt = u
ulowu = u
while ulowu[-1] == 0:
ulowt, ulowu = ulowu[-3:-1]
a = '_array' if ulowt == 'vector' else ''
a += '_almost' if ulowu not in ['str', 'char'] else ''
if a != '' and "NPY_" not in ts.cython_nptype(ulowu):
return ""
return _testmap.format(*[repr(i) for i in testvals[t] + testvals[u][::-1]],
tclsname=ts.cython_classname(t)[1],
uclsname=ts.cython_classname(u)[1],
tfncname=ts.cython_functionname(t)[1],
ufncname=ts.cython_functionname(u)[1],
array=a, stlcontainers=ts.stlcontainers)
#
# Vectors
#
_pyxvector = """# {ctype} vector
"""
[docs]def genpyx_vector(t, ts):
"""Returns the pyx snippet for a vector of type t."""
t = ts.canon(t)
kw = dict(ctype=ts.cython_ctype(t), )
return _pyxvector.format(**kw)
_pxdvector = """# {ctype} vector
"""
[docs]def genpxd_vector(t, ts):
"""Returns the pxd snippet for a vector of type t."""
t = ts.canon(t)
kw = dict(ctype=ts.cython_ctype(t), )
return _pxdvector.format(**kw)
_testvector = """# Vector {clsname}
"""
[docs]def gentest_vector(t, ts):
"""Returns the test snippet for a set of type t."""
t = ts.canon(t)
if ('vector', t, 0) in testvals:
s = _testvector.format(*[repr(i) for i in testvals['vector', t, 0]],
clsname=ts.cython_classname(t)[1])
else:
s = ""
return s
#
# Controlers
#
_pyxheader = """###################
### WARNING!!! ###
###################
# This file has been autogenerated
# Cython imports
from cython.operator cimport dereference as deref
from cython.operator cimport preincrement as inc
from libc.stdlib cimport malloc, free
from libc.string cimport memcpy
from libcpp.string cimport string as std_string
from libcpp.utility cimport pair
from libcpp.map cimport map as cpp_map
from libcpp.set cimport set as cpp_set
from libcpp cimport bool as cpp_bool
from libcpp.vector cimport vector as cpp_vector
from cpython.version cimport PY_MAJOR_VERSION
# Python Imports
import collections
cimport numpy as np
import numpy as np
np.import_array()
cimport {extra_types}
# Cython Imports For Types
{cimports}
# Imports For Types
{imports}
if PY_MAJOR_VERSION >= 3:
basestring = str
# Dirty ifdef, else, else preprocessor hack
# see http://comments.gmane.org/gmane.comp.python.cython.user/4080
cdef extern from *:
cdef void emit_ifpy2k "#if PY_MAJOR_VERSION == 2 //" ()
cdef void emit_ifpy3k "#if PY_MAJOR_VERSION == 3 //" ()
cdef void emit_else "#else //" ()
cdef void emit_endif "#endif //" ()
"""
def genpyx(template, header=None, ts=None):
ts = ts or TypeSystem()
"""Returns a string of a pyx file representing the given template."""
pyxfuncs = dict([(k[7:], v) for k, v in globals().items() \
if k.startswith('genpyx_') and callable(v)])
pyx = _pyxheader if header is None else header
with ts.swap_stlcontainers(None):
import_tups = set()
cimport_tups = set()
for t in template:
for arg in t[1:]:
ts.cython_import_tuples(arg, import_tups)
ts.cython_cimport_tuples(arg, cimport_tups)
imports = "\n".join(ts.cython_import_lines(import_tups))
cimports = "\n".join(ts.cython_cimport_lines(cimport_tups))
pyx = pyx.format(extra_types=ts.extra_types, cimports=cimports,
imports=imports)
for t in template:
pyx += pyxfuncs[t[0]](*t[1:], ts=ts) + "\n\n"
return pyx
_pxdheader = """###################
### WARNING!!! ###
###################
# This file has been autogenerated
# Cython imports
from cython.operator cimport dereference as deref
from cython.operator cimport preincrement as inc
from libcpp.string cimport string as std_string
from libcpp.utility cimport pair
from libcpp.map cimport map as cpp_map
from libcpp.set cimport set as cpp_set
from libcpp.vector cimport vector as cpp_vector
from libcpp cimport bool as cpp_bool
from libc cimport stdio
from cpython.version cimport PY_MAJOR_VERSION
from cpython.ref cimport PyTypeObject, Py_INCREF, Py_XDECREF
# Python Imports
cimport numpy as np
# Local imports
cimport {extra_types}
cimport numpy as np
# Cython Imports For Types
{cimports}
"""
[docs]def genpxd(template, header=None, ts=None):
"""Returns a string of a pxd file representing the given template."""
ts = ts or TypeSystem()
pxdfuncs = dict([(k[7:], v) for k, v in globals().items() \
if k.startswith('genpxd_') and callable(v)])
pxd = _pxdheader if header is None else header
with ts.swap_stlcontainers(None):
cimport_tups = set()
for t in template:
for arg in t[1:]:
ts.cython_cimport_tuples(arg, cimport_tups, set(['c']))
cimports = "\n".join(ts.cython_cimport_lines(cimport_tups))
pxd = pxd.format(extra_types=ts.extra_types, cimports=cimports)
for t in template:
pxd += pxdfuncs[t[0]](*t[1:], ts=ts) + "\n\n"
return pxd
_testheader = '''"""Tests the part of stlconverters that is accessible from Python."""
###################
### WARNING!!! ###
###################
# This file has been autogenerated
from __future__ import print_function
from unittest import TestCase
import nose
from nose.tools import assert_equal, assert_not_equal, assert_raises, raises, \\
assert_almost_equal, assert_true, assert_false, assert_in
from numpy.testing import assert_array_equal, assert_array_almost_equal
import os
import numpy as np
from collections import Container, Mapping
from {package} import {stlcontainers}
'''
_testfooter = '''if __name__ == '__main__':
nose.run()
'''
[docs]def gentest(template, header=None, package='..', ts=None):
"""Returns a string of a test file representing the given template."""
ts = ts or TypeSystem()
testfuncs = dict([(k[8:], v) for k, v in globals().items() \
if k.startswith('gentest_') and callable(v)])
test = _testheader if header is None else header
test = test.format(stlcontainers=ts.stlcontainers, package=package)
for t in template:
test += testfuncs[t[0]](*t[1:], ts=ts) + "\n\n"
test += _testfooter
return test
[docs]def genfiles(template, fname='temp', pxdname=None, testname=None,
pyxheader=None, pxdheader=None, testheader=None, package='..',
ts=None, verbose=False):
"""Generates all cython source files needed to create the wrapper."""
ts = ts or TypeSystem()
# munge some filenames
fname = fname[:-4] if fname.endswith('.pyx') else fname
pxdname = fname if pxdname is None else pxdname
pxdname = pxdname + '.pxd' if not pxdname.endswith('.pxd') else pxdname
testname = 'test_' + fname if testname is None else testname
testname = testname + '.py' if not testname.endswith('.py') else testname
fname += '.pyx'
pyx = genpyx(template, pyxheader, ts=ts)
pxd = genpxd(template, pxdheader, ts=ts)
test = gentest(template, testheader, package, ts=ts)
newoverwrite(pyx, fname, verbose)
newoverwrite(pxd, pxdname, verbose)
newoverwrite(test, testname, verbose)
#
# XDress Plugin
#
[docs]class XDressPlugin(Plugin):
"""This class provides extra type functionality for xdress."""
requires = ('xdress.base', 'xdress.extratypes', 'xdress.dtypes')
defaultrc = RunControl(
stlcontainers=[],
#stlcontainers_module='stlcontainers', # Moved to base plugin
make_stlcontainers=True,
)
rcdocs = {
"stlcontainers": "List of C++ standard library containers to wrap.",
"make_stlcontainers": ("Flag for enabling / disabling creating the "
"C++ standard library container wrappers."),
}
def update_argparser(self, parser):
parser.add_argument('--make-stlcontainers', action='store_true',
dest='make_stlcontainers', help="make C++ STL container wrappers")
parser.add_argument('--no-make-stlcontainers', action='store_false',
dest='make_stlcontainers', help="don't make C++ STL container wrappers")
def setup(self, rc):
print("stlwrap: registering C++ standard library types")
ts = rc.ts
# register dtypes
for t in rc.stlcontainers:
if t[0] == 'vector' and t[1] not in rc.dtypes:
rc.dtypes.append(t[1])
ts.register_numpy_dtype(t[1])
def execute(self, rc):
if not rc.make_stlcontainers:
return
print("stlwrap: generating C++ standard library wrappers & converters")
fname = os.path.join(rc.packagedir, rc.stlcontainers_module)
ensuredirs(fname)
testname = 'test_' + rc.stlcontainers_module
testname = os.path.join(rc.packagedir, 'tests', testname)
ensuredirs(testname)
genfiles(rc.stlcontainers, fname=fname, testname=testname, package=rc.package,
ts=rc.ts, verbose=rc.verbose)
