static inline PyObject* execute(Arg& x)
{
BOOST_MPL_ASSERT((mpl::or_<is_class<T>, is_union<T> >));
PyTypeObject* type = Derived::get_class_object(x);
if (type == 0)
return python::detail::none();
PyObject* raw_result = type->tp_alloc(
type, objects::additional_instance_size<Holder>::value);
if (raw_result != 0)
{
python::detail::decref_guard protect(raw_result);
instance_t* instance = (instance_t*)raw_result;
// construct the new C++ object and install the pointer
// in the Python object.
Derived::construct(&instance->storage, (PyObject*)instance, x)->install(raw_result);
// Note the position of the internally-stored Holder,
// for the sake of destruction
Py_SIZE(instance) = offsetof(instance_t, storage);
// Release ownership of the python object
protect.cancel();
}
return raw_result;
}
template <typename U> static PyObject *c2py(U &&x) {
PyTypeObject *p = get_type_ptr(typeid(T));
if (p == nullptr) return NULL;
py_type *self = (py_type *)p->tp_alloc(p, 0);
if (self != NULL) { self->_c = new T{std::forward<U>(x)}; }
return (PyObject *)self;
}
static PyObject* reconstruct(PyObject* self, PyObject* args)
{
PyTypeObject* klass;
PyObject* base;
PyObject* state;
if (!PyArg_ParseTuple(args, "OOO", &klass, &base, &state))
return NULL;
if (!PyType_Check(klass)) {
PyErr_SetString(PyExc_TypeError, "argument 1 must be a type object");
return NULL;
}
if (!PyType_Check(base)) {
PyErr_SetString(PyExc_TypeError, "argument 2 must be a type object");
return NULL;
}
if (!PyTuple_Check(state)) {
PyErr_SetString(PyExc_TypeError, "argument 3 must be a tuple");
return NULL;
}
return klass->tp_new(klass, state, NULL);
}
/* PycairoFontFace_FromFontFace
* Create a new PycairoFontFace from a cairo_font_face_t
* font_face - a cairo_font_face_t to 'wrap' into a Python object.
* it is unreferenced if the PycairoFontFace creation fails
* Return value: New reference or NULL on failure
*/
PyObject *
PycairoFontFace_FromFontFace (cairo_font_face_t *font_face)
{
PyTypeObject *type = NULL;
PyObject *o;
assert (font_face != NULL);
if (Pycairo_Check_Status (cairo_font_face_status (font_face))) {
cairo_font_face_destroy (font_face);
return NULL;
}
switch (cairo_font_face_get_type (font_face)) {
case CAIRO_FONT_TYPE_TOY:
type = &PycairoToyFontFace_Type;
break;
default:
type = &PycairoFontFace_Type;
break;
}
o = type->tp_alloc (type, 0);
if (o == NULL)
cairo_font_face_destroy (font_face);
else
((PycairoFontFace *)o)->font_face = font_face;
return o;
}
PyObject*
IcePy::createConnectionInfo(const Ice::ConnectionInfoPtr& connectionInfo)
{
PyTypeObject* type;
if(Ice::TCPConnectionInfoPtr::dynamicCast(connectionInfo))
{
type = &TCPConnectionInfoType;
}
else if(Ice::UDPConnectionInfoPtr::dynamicCast(connectionInfo))
{
type = &UDPConnectionInfoType;
}
else if(Ice::IPConnectionInfoPtr::dynamicCast(connectionInfo))
{
type = &IPConnectionInfoType;
}
else
{
type = &ConnectionInfoType;
}
ConnectionInfoObject* obj = reinterpret_cast<ConnectionInfoObject*>(type->tp_alloc(type, 0));
if(!obj)
{
return 0;
}
obj->connectionInfo = new Ice::ConnectionInfoPtr(connectionInfo);
return (PyObject*)obj;
}
PyObject* GeometryPy::copy(PyObject *args)
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
Part::Geometry* geom = this->getGeometryPtr();
PyTypeObject* type = this->GetType();
PyObject* cpy = 0;
// let the type object decide
if (type->tp_new)
cpy = type->tp_new(type, this, 0);
if (!cpy) {
PyErr_SetString(PyExc_TypeError, "failed to create copy of geometry");
return 0;
}
Part::GeometryPy* geompy = static_cast<Part::GeometryPy*>(cpy);
// the PyMake function must have created the corresponding instance of the 'Geometry' subclass
// so delete it now to avoid a memory leak
if (geompy->_pcTwinPointer) {
Part::Geometry* clone = static_cast<Part::Geometry*>(geompy->_pcTwinPointer);
delete clone;
}
geompy->_pcTwinPointer = geom->copy();
return cpy;
}
/**
* Factory function for a CArray used if only the number of items is known given.
*
* Note that this method does not increment the reference counter. You are responsible for
* calling Py_INCREF(obj) in the returned obj yourself
*/
PyObject* CArray_createFromLength(const char* format, int length) {
PyTypeObject* type = &CArray_Type;
CArrayObj* self;
void* items;
size_t item_size;
item_size = CArray_getItemSize(format);
if (item_size <= 0) {
return NULL;
}
items = calloc(item_size, length);
if (items == NULL) {
PyErr_SetString(PyExc_MemoryError, "out of memory");
return NULL;
}
if (length <= 0) {
PyErr_SetString(PyExc_ValueError, "length must be > 0");
return NULL;
}
self = (CArrayObj*) type->tp_alloc(type, 0);
CArray_initInstance(self, format, items, item_size, length, CArray_releaseElements);
return (PyObject*) self;
}
static upb_sflow_t PyUpb_Message_StartSubmessage(void *m, upb_value fval) {
PyObject **submsg = PyUpb_Accessor_GetPtr(m, fval);
PyTypeObject *type = Py_TYPE(m);
if (!*submsg) *submsg = type->tp_alloc(type, 0);
upb_stdmsg_sethas(m, fval);
return UPB_CONTINUE_WITH(*submsg);
}
static upb_sflow_t PyUpb_Message_StartSequence(void *m, upb_value fval) {
PyObject **seq = PyUpb_Accessor_GetPtr(m, fval);
PyTypeObject *type = ((PyUpb_MessageType*)Py_TYPE(m))->alt_type;
if (!*seq) *seq = type->tp_alloc(type, 0);
upb_stdmsg_sethas(m, fval);
return UPB_CONTINUE_WITH(*seq);
}
static PyObject *
_K_subscript(_K *self, PyObject *key)
{
int i;
K kobj = self->kobj;
char *skey;
int key_length;
int value_index = 1;
if (kobj->t != 5) {
PyErr_Format(PyExc_TypeError,
"k object of type %d is not a dictionary", kobj->t);
return NULL;
}
if (-1 == PyString_AsStringAndSize(key, &skey, &key_length)) {
return NULL;
}
if (skey[key_length-1] == '.') {
--key_length;
++value_index;
}
for (i=0; i < kobj->n; ++i) {
K e = KK(kobj)[i];
if (0 == strncmp(skey,Ks(KK(e)[0]),key_length)) {
PyTypeObject* type = self->ob_type;
_K* k = (_K*)type->tp_alloc(type, 0);
k->kobj = ci(KK(e)[value_index]);
return (PyObject*)k;
}
}
PyErr_SetObject(PyExc_KeyError, key);
return NULL;
}
PyObject *
pygi_struct_new_from_g_type (GType g_type,
gpointer pointer,
gboolean free_on_dealloc)
{
PyGIStruct *self;
PyTypeObject *type;
type = (PyTypeObject *)pygi_type_import_by_g_type (g_type);
if (!type)
type = (PyTypeObject *)&PyGIStruct_Type; /* fallback */
if (!PyType_IsSubtype (type, &PyGIStruct_Type)) {
PyErr_SetString (PyExc_TypeError, "must be a subtype of gi.Struct");
return NULL;
}
self = (PyGIStruct *) type->tp_alloc (type, 0);
if (self == NULL) {
return NULL;
}
pyg_pointer_set_ptr (self, pointer);
( (PyGPointer *) self)->gtype = g_type;
self->free_on_dealloc = free_on_dealloc;
return (PyObject *) self;
}
PyObject*
IcePy::createEndpointInfo(const Ice::EndpointInfoPtr& endpointInfo)
{
PyTypeObject* type;
if(Ice::TCPEndpointInfoPtr::dynamicCast(endpointInfo))
{
type = &TCPEndpointInfoType;
}
else if(Ice::UDPEndpointInfoPtr::dynamicCast(endpointInfo))
{
type = &UDPEndpointInfoType;
}
else if(Ice::OpaqueEndpointInfoPtr::dynamicCast(endpointInfo))
{
type = &OpaqueEndpointInfoType;
}
else if(Ice::IPEndpointInfoPtr::dynamicCast(endpointInfo))
{
type = &IPEndpointInfoType;
}
else
{
type = &EndpointInfoType;
}
EndpointInfoObject* obj = reinterpret_cast<EndpointInfoObject*>(type->tp_alloc(type, 0));
if(!obj)
{
return 0;
}
obj->endpointInfo = new Ice::EndpointInfoPtr(endpointInfo);
return (PyObject*)obj;
}
/*
* Create main Fiber. There is always a main Fiber for a given (real) thread,
* and it's parent is always NULL.
*/
static Fiber *
fiber_create_main(void)
{
Fiber *t_main;
PyObject *dict = PyThreadState_GetDict();
PyTypeObject *cls = (PyTypeObject *)&FiberType;
if (dict == NULL) {
if (!PyErr_Occurred()) {
PyErr_NoMemory();
}
return NULL;
}
/* create the main Fiber for this thread */
t_main = (Fiber *)cls->tp_new(cls, NULL, NULL);
if (!t_main) {
return NULL;
}
Py_INCREF(dict);
t_main->ts_dict = dict;
t_main->parent = NULL;
t_main->thread_h = stacklet_newthread();
t_main->stacklet_h = NULL;
t_main->initialized = True;
t_main->is_main = True;
return t_main;
}
static upb_sflow_t PyUpb_Message_StartRepeatedSubmessage(
void *a, upb_value fval) {
(void)fval;
PyObject **elem = upb_stdarray_append(a, sizeof(void*));
PyTypeObject *type = ((PyUpb_MessageType*)Py_TYPE(a))->alt_type;
if (!*elem) *elem = type->tp_alloc(type, 0);
return UPB_CONTINUE_WITH(*elem);
}
/* PycairoSurface_FromSurface
* Create a new
* PycairoImageSurface,
* PycairoPDFSurface,
* PycairoPSSurface,
* PycairoSVGSurface,
* PycairoWin32Surface, or
* PycairoXlibSurface from a cairo_surface_t.
* surface - a cairo_surface_t to 'wrap' into a Python object.
* It is unreferenced if the PycairoSurface creation fails, or if the
* cairo_surface_t has an error status.
* base - the base object used to create the surface, or NULL.
* It is referenced to keep it alive while the cairo_surface_t is being used.
* Return value: New reference or NULL on failure
*/
PyObject *
PycairoSurface_FromSurface (cairo_surface_t *surface, PyObject *base)
{
PyTypeObject *type = NULL;
PyObject *o;
assert (surface != NULL);
if (Pycairo_Check_Status (cairo_surface_status (surface))) {
cairo_surface_destroy (surface);
return NULL;
}
switch (cairo_surface_get_type (surface)) {
#if CAIRO_HAS_IMAGE_SURFACE
case CAIRO_SURFACE_TYPE_IMAGE:
type = &PycairoImageSurface_Type;
break;
#endif
#if CAIRO_HAS_PDF_SURFACE
case CAIRO_SURFACE_TYPE_PDF:
type = &PycairoPDFSurface_Type;
break;
#endif
#if CAIRO_HAS_PS_SURFACE
case CAIRO_SURFACE_TYPE_PS:
type = &PycairoPSSurface_Type;
break;
#endif
#if CAIRO_HAS_SVG_SURFACE
case CAIRO_SURFACE_TYPE_SVG:
type = &PycairoSVGSurface_Type;
break;
#endif
#if CAIRO_HAS_WIN32_SURFACE
case CAIRO_SURFACE_TYPE_WIN32:
type = &PycairoWin32Surface_Type;
break;
#endif
#if CAIRO_HAS_XLIB_SURFACE
case CAIRO_SURFACE_TYPE_XLIB:
type = &PycairoXlibSurface_Type;
break;
#endif
default:
type = &PycairoSurface_Type;
break;
}
o = type->tp_alloc (type, 0);
if (o == NULL) {
cairo_surface_destroy (surface);
} else {
((PycairoSurface *)o)->surface = surface;
Py_XINCREF(base);
((PycairoSurface *)o)->base = base;
}
return o;
}
static int
exc_traverse (zbarException *self,
visitproc visit,
void *arg)
{
Py_VISIT(self->obj);
PyTypeObject *base = (PyTypeObject*)PyExc_Exception;
return(base->tp_traverse((PyObject*)self, visit, arg));
}
inline PyObject* create_RegionMapObject(const RegionMap& d) {
PyTypeObject* t = get_RegionMapType();
if (t == 0)
return 0;
RegionMapObject* so;
so = (RegionMapObject*)t->tp_alloc(t, 0);
so->m_x = new RegionMap(d);
return (PyObject*)so;
}
inline PyObject* create_RegionObject(const Region& d) {
PyTypeObject* t = get_RegionType();
if (t == 0)
return 0;
RegionObject* so;
so = (RegionObject*)t->tp_alloc(t, 0);
((RectObject*)so)->m_x = new Region(d);
return (PyObject*)so;
}
inline PyObject* create_RGBPixelObject(const RGBPixel& d) {
PyTypeObject* t = get_RGBPixelType();
if (t == 0)
return 0;
RGBPixelObject* so;
so = (RGBPixelObject*)t->tp_alloc(t, 0);
so->m_x = new RGBPixel(d);
return (PyObject*)so;
}
inline PyObject* create_FloatPointObject(const FloatPoint& d) {
PyTypeObject* t = get_FloatPointType();
if (t == 0)
return 0;
FloatPointObject* so;
so = (FloatPointObject*)t->tp_alloc(t, 0);
so->m_x = new FloatPoint(d);
return (PyObject*)so;
}
inline PyObject* create_DimObject(const Dim& d) {
PyTypeObject* t = get_DimType();
if (t == 0)
return 0;
DimObject* so;
so = (DimObject*)t->tp_alloc(t, 0);
so->m_x = new Dim(d);
return (PyObject*)so;
}
inline PyObject* create_SizeObject(const Size& d) {
PyTypeObject* t = get_SizeType();
if (t == 0)
return 0;
SizeObject* so;
so = (SizeObject*)t->tp_alloc(t, 0);
so->m_x = new Size(d);
return (PyObject*)so;
}
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
PyTypeObject* tp = Py_TYPE(obj);
if (likely(tp->tp_getattro))
return tp->tp_getattro(obj, attr_name);
#if PY_MAJOR_VERSION < 3
if (likely(tp->tp_getattr))
return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
#endif
return PyObject_GetAttr(obj, attr_name);
}
static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc) {
PyTypeObject* type = Py_TYPE(obj);
/* try to find the first parent type that has a different tp_dealloc() function */
while (type && type->tp_dealloc != current_tp_dealloc)
type = type->tp_base;
while (type && type->tp_dealloc == current_tp_dealloc)
type = type->tp_base;
if (type)
type->tp_dealloc(obj);
}
static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) {
PyTypeObject* type = Py_TYPE(obj);
/* try to find the first parent type that has a different tp_clear() function */
while (type && type->tp_clear != current_tp_clear)
type = type->tp_base;
while (type && type->tp_clear == current_tp_clear)
type = type->tp_base;
if (type && type->tp_clear)
type->tp_clear(obj);
}
AerospikeKey * AerospikeKey_New(AerospikeClient * client, PyObject * args, PyObject * kwds)
{
Py_INCREF(client);
Py_INCREF(args);
AerospikeKey * self = (AerospikeKey *) AerospikeKey_Type.tp_new(&AerospikeKey_Type, args, kwds);
self->client = client;
self->key = args;
AerospikeKey_Type.tp_init((PyObject *) self, args, kwds);
return self;
}
static PyObject*
SortedMap_copy( SortedMap* self )
{
PyTypeObject* type = pytype_cast( self->ob_type );
PyObject* copy = type->tp_alloc( type, 0 );
if( !copy )
return 0;
SortedMap* ccopy = reinterpret_cast<SortedMap*>( copy );
ccopy->sortedmap = new sortedmap_t();
*ccopy->sortedmap = *self->sortedmap;
return copy;
}
PyObject *DyND_PyWrapper_New(const T &v)
{
PyTypeObject *type = DyND_PyWrapper_Type<T>();
DyND_PyWrapperObject<T> *obj =
reinterpret_cast<DyND_PyWrapperObject<T> *>(type->tp_alloc(type, 0));
if (obj == NULL) {
throw std::runtime_error("");
}
new (&obj->v) T(v);
return reinterpret_cast<PyObject *>(obj);
}
static PyObject*
SortedMap_copy( SortedMap* self )
{
PyTypeObject* type = pytype_cast( Py_TYPE(self) );
PyObject* copy = type->tp_alloc( type, 0 );
if( !copy )
return 0;
SortedMap* ccopy = reinterpret_cast<SortedMap*>( copy );
ccopy->m_items = new SortedMap::Items();
*ccopy->m_items = *self->m_items;
return copy;
}
PyObject * THPStorage_(New)(THStorage *ptr)
{
TORCH_ASSERT(ptr);
PyTypeObject *type = (PyTypeObject *)THPStorageClass;
PyObject *obj = type->tp_alloc(type, 0);
if (obj) {
((THPStorage *)obj)->cdata = ptr;
} else {
THStorage_(free)(LIBRARY_STATE ptr);
}
return obj;
}
