189 lines
7.1 KiB
Cython
189 lines
7.1 KiB
Cython
# addressbook_fast.pyx
|
|
# distutils: language = c++
|
|
# distutils: extra_compile_args = --std=c++11
|
|
# distutils: include_dirs = {{include_dir}}
|
|
# distutils: libraries = capnpc capnp capnp-rpc
|
|
# distutils: sources = {{file.filename}}.cpp
|
|
# cython: c_string_type = str
|
|
# cython: c_string_encoding = default
|
|
# cython: embedsignature = True
|
|
|
|
import capnp
|
|
import {{file.filename | replace('.', '_')}}
|
|
|
|
from libcpp cimport bool as cbool
|
|
from capnp cimport helpers
|
|
from capnp.includes.capnp_cpp cimport DynamicValue, Schema, VOID, StringPtr
|
|
from capnp.lib.capnp cimport _DynamicStructReader, _DynamicStructBuilder, _DynamicListBuilder, _DynamicEnum, _StructSchemaField, to_python_builder, to_python_reader, _to_dict, _setDynamicFieldStatic, _Schema, _InterfaceSchema
|
|
|
|
from capnp.helpers.non_circular cimport reraise_kj_exception
|
|
|
|
cdef DynamicValue.Reader _extract_dynamic_struct_builder(_DynamicStructBuilder value):
|
|
return DynamicValue.Reader(value.thisptr.asReader())
|
|
|
|
cdef DynamicValue.Reader _extract_dynamic_struct_reader(_DynamicStructReader value):
|
|
return DynamicValue.Reader(value.thisptr)
|
|
|
|
cdef DynamicValue.Reader _extract_dynamic_enum(_DynamicEnum value):
|
|
return DynamicValue.Reader(value.thisptr)
|
|
|
|
cdef _from_dict(_DynamicStructBuilder msg, dict d):
|
|
for key, val in d.iteritems():
|
|
if key != 'which':
|
|
try:
|
|
msg._set(key, val)
|
|
except Exception as e:
|
|
if 'expected isSetInUnion(field)' in str(e):
|
|
msg.init(key)
|
|
msg._set(key, val)
|
|
|
|
cdef _from_list(_DynamicListBuilder msg, list d):
|
|
cdef size_t count = 0
|
|
for val in d:
|
|
msg._set(count, val)
|
|
count += 1
|
|
|
|
cdef DynamicValue.Reader to_dynamic_value(value):
|
|
cdef DynamicValue.Reader temp
|
|
cdef StringPtr temp_string
|
|
value_type = type(value)
|
|
|
|
if value_type is int or value_type is long:
|
|
if value < 0:
|
|
temp = DynamicValue.Reader(<long long>value)
|
|
else:
|
|
temp = DynamicValue.Reader(<unsigned long long>value)
|
|
elif value_type is float:
|
|
temp = DynamicValue.Reader(<double>value)
|
|
elif value_type is bool:
|
|
temp = DynamicValue.Reader(<cbool>value)
|
|
elif value_type is bytes:
|
|
temp_string = StringPtr(<char*>value, len(value))
|
|
temp = DynamicValue.Reader(temp_string)
|
|
elif isinstance(value, basestring):
|
|
encoded_value = value.encode()
|
|
temp_string = StringPtr(<char*>encoded_value, len(encoded_value))
|
|
temp = DynamicValue.Reader(temp_string)
|
|
elif value is None:
|
|
temp = DynamicValue.Reader(VOID)
|
|
elif value_type is _DynamicStructBuilder:
|
|
temp = _extract_dynamic_struct_builder(value)
|
|
elif value_type is _DynamicStructReader:
|
|
temp = _extract_dynamic_struct_reader(value)
|
|
elif value_type is _DynamicEnum:
|
|
temp = _extract_dynamic_enum(value)
|
|
else:
|
|
raise ValueError("Tried to convert value of: '{}' which is an unsupported type: '{}'".format(str(value), str(type(value))))
|
|
|
|
return temp
|
|
|
|
|
|
cdef extern from "{{file.filename}}.h":
|
|
{%- for node in code.nodes %}
|
|
Schema get{{node.module_name}}Schema"capnp::Schema::from<{{node.c_module_path}}>"()
|
|
|
|
cdef cppclass {{node.module_name}}"{{node.c_module_path}}":
|
|
cppclass Reader:
|
|
{%- for field in node.struct.fields %}
|
|
DynamicValue.Reader get{{field.c_name}}()
|
|
{%- endfor %}
|
|
cppclass Builder:
|
|
{%- for field in node.struct.fields %}
|
|
DynamicValue.Builder get{{field.c_name}}()
|
|
set{{field.c_name}}(DynamicValue.Reader)
|
|
{%- endfor %}
|
|
{%- endfor %}
|
|
|
|
cdef cppclass C_DynamicStruct_Reader" ::capnp::DynamicStruct::Reader":
|
|
{%- for node in code.nodes %}
|
|
{{node.module_name}}.Reader as{{node.module_name}}"as<{{node.c_module_path}}>"()
|
|
{%- endfor %}
|
|
|
|
cdef cppclass C_DynamicStruct_Builder" ::capnp::DynamicStruct::Builder":
|
|
{%- for node in code.nodes %}
|
|
{{node.module_name}}.Builder as{{node.module_name}}"as<{{node.c_module_path}}>"()
|
|
{%- endfor %}
|
|
|
|
{%- for node in code.nodes %}
|
|
|
|
{{node.schema}} = _Schema()._init(get{{node.module_name}}Schema()).as_struct()
|
|
{{node.module_path}}.schema = {{node.schema}}
|
|
|
|
cdef class {{node.module_name}}_Reader(_DynamicStructReader):
|
|
cdef {{node.module_name}}.Reader thisptr_child
|
|
def __init__(self, _DynamicStructReader struct):
|
|
self._init(struct.thisptr, struct._parent, struct.is_root, False)
|
|
self.thisptr_child = (<C_DynamicStruct_Reader>struct.thisptr).as{{node.module_name}}()
|
|
{% for field in node.struct.fields %}
|
|
cpdef _get_{{field.name}}(self) except +reraise_kj_exception:
|
|
cdef DynamicValue.Reader temp = self.thisptr_child.get{{field.c_name}}()
|
|
return to_python_reader(temp, self._parent)
|
|
property {{field.name}}:
|
|
def __get__(self):
|
|
return self._get_{{field.name}}()
|
|
{%- endfor %}
|
|
|
|
def to_dict(self, verbose=False):
|
|
ret = {
|
|
{% for field in node.struct.fields %}
|
|
{% if field.discriminantValue == 65535 %}
|
|
'{{field.name}}': _to_dict(self.{{field.name}}, verbose),
|
|
{% endif %}
|
|
{%- endfor %}
|
|
}
|
|
|
|
{% if node.is_union %}
|
|
which = self.which()
|
|
ret[which] = getattr(self, which)
|
|
{% endif %}
|
|
|
|
return ret
|
|
|
|
cdef class {{node.module_name}}_Builder(_DynamicStructBuilder):
|
|
cdef {{node.module_name}}.Builder thisptr_child
|
|
def __init__(self, _DynamicStructBuilder struct):
|
|
self._init(struct.thisptr, struct._parent, struct.is_root, False)
|
|
self.thisptr_child = (<C_DynamicStruct_Builder>struct.thisptr).as{{node.module_name}}()
|
|
{% for field in node.struct.fields %}
|
|
cpdef _get_{{field.name}}(self) except +reraise_kj_exception:
|
|
cdef DynamicValue.Builder temp = self.thisptr_child.get{{field.c_name}}()
|
|
return to_python_builder(temp, self._parent)
|
|
cpdef _set_{{field.name}}(self, value) except +reraise_kj_exception:
|
|
_setDynamicFieldStatic(self.thisptr, "{{field.name}}", value, self._parent)
|
|
# cdef DynamicValue.Builder temp
|
|
# value_type = type(value)
|
|
# if value_type is list:
|
|
# builder = to_python_builder(self.thisptr_child.get{{field.c_name}}(), self._parent)
|
|
# _from_list(builder, value)
|
|
# elif value_type is dict:
|
|
# builder = to_python_builder(self.thisptr_child.get{{field.c_name}}(), self._parent)
|
|
# _from_dict(builder, value)
|
|
# else:
|
|
# self.thisptr_child.set{{field.c_name}}(to_dynamic_value(value))
|
|
|
|
property {{field.name}}:
|
|
def __get__(self):
|
|
return self._get_{{field.name}}()
|
|
def __set__(self, value):
|
|
self._set_{{field.name}}(value)
|
|
{%- endfor %}
|
|
|
|
def to_dict(self, verbose=False):
|
|
ret = {
|
|
{% for field in node.struct.fields %}
|
|
{% if field.discriminantValue == 65535 %}
|
|
'{{field.name}}': _to_dict(self.{{field.name}}, verbose),
|
|
{% endif %}
|
|
{%- endfor %}
|
|
}
|
|
|
|
{% if node.is_union %}
|
|
which = self.which()
|
|
ret[which] = getattr(self, which)
|
|
{% endif %}
|
|
|
|
return ret
|
|
|
|
capnp.register_type({{node.id}}, ({{node.module_name}}_Reader, {{node.module_name}}_Builder))
|
|
{% endfor %}
|