本文整理汇总了C++中PyTuple_Size函数的典型用法代码示例。如果您正苦于以下问题:C++ PyTuple_Size函数的具体用法?C++ PyTuple_Size怎么用?C++ PyTuple_Size使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了PyTuple_Size函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: PyErr_Format
PyObject *wsgi_convert_headers_to_bytes(PyObject *headers)
{
PyObject *result = NULL;
int i;
long size;
if (!PyList_Check(headers)) {
PyErr_Format(PyExc_TypeError, "expected list object for headers, "
"value of type %.200s found", headers->ob_type->tp_name);
return 0;
}
size = PyList_Size(headers);
result = PyList_New(size);
for (i = 0; i < size; i++) {
PyObject *header = NULL;
PyObject *header_name = NULL;
PyObject *header_value = NULL;
PyObject *header_name_as_bytes = NULL;
PyObject *header_value_as_bytes = NULL;
PyObject *result_tuple = NULL;
header = PyList_GetItem(headers, i);
if (!PyTuple_Check(header)) {
PyErr_Format(PyExc_TypeError, "list of tuple values "
"expected for headers, value of type %.200s found",
header->ob_type->tp_name);
Py_DECREF(result);
return 0;
}
if (PyTuple_Size(header) != 2) {
PyErr_Format(PyExc_ValueError, "tuple of length 2 "
"expected for header, length is %d",
(int)PyTuple_Size(header));
Py_DECREF(result);
return 0;
}
result_tuple = PyTuple_New(2);
PyList_SET_ITEM(result, i, result_tuple);
header_name = PyTuple_GetItem(header, 0);
header_value = PyTuple_GetItem(header, 1);
header_name_as_bytes = wsgi_convert_string_to_bytes(header_name);
if (!header_name_as_bytes)
goto failure;
PyTuple_SET_ITEM(result_tuple, 0, header_name_as_bytes);
if (!wsgi_validate_header_name(header_name_as_bytes))
goto failure;
header_value_as_bytes = wsgi_convert_string_to_bytes(header_value);
if (!header_value_as_bytes)
goto failure;
PyTuple_SET_ITEM(result_tuple, 1, header_value_as_bytes);
if (!wsgi_validate_header_value(header_value_as_bytes))
goto failure;
}
return result;
failure:
Py_DECREF(result);
return NULL;
}
示例2: dataconv_ReadFromInTuple
PyObject * dataconv_ReadFromInTuple(PyObject *self, PyObject *args)
{
PyObject *obArgTypes;
PyObject *obArgType;
PyObject *obPtr;
BYTE *pb;
BYTE *pbArg;
Py_ssize_t cArgs, i;
PyObject *obArgs = NULL;
PyObject *obArg;
VARTYPE vtArgType;
UINT cb;
VARIANT var;
BOOL bIsByRef;
if (!PyArg_ParseTuple(args, "OO:ReadFromInTuple", &obArgTypes, &obPtr))
return NULL;
pbArg = (BYTE *)PyLong_AsVoidPtr(obPtr);
assert(pbArg);
if (!pbArg)
return NULL;
pb = pbArg;
if (!PyTuple_Check(obArgTypes))
{
PyErr_SetString(PyExc_TypeError, "OLE type description - expecting a tuple");
return NULL;
}
cArgs = PyTuple_Size(obArgTypes);
obArgs = PyTuple_New(cArgs);
if (!obArgs)
return NULL;
for(i = 0 ; i < cArgs; i++)
{
// (<type tuple>, argPtr offset, arg size)
if (PyTuple_Size(PyTuple_GET_ITEM(obArgTypes, i)) != 3)
{
PyErr_SetString(PyExc_TypeError, "OLE type description - expecting an arg desc tuple of size 3");
goto Error;
}
obArgType = PyTuple_GET_ITEM(PyTuple_GET_ITEM(obArgTypes, i), 0);
// Position pb to point to the current argument.
pb = pbArg + PyInt_AS_LONG(PyTuple_GET_ITEM(PyTuple_GET_ITEM(obArgTypes, i), 1));
vtArgType = (VARTYPE)PyInt_AS_LONG(obArgType);
#ifdef _M_IX86
bIsByRef = vtArgType & VT_BYREF;
#elif _M_X64
// params > 64bits always passed by address - and the only
// arg we support > 64 bits is a VARIANT structure.
bIsByRef = (vtArgType==VT_VARIANT) || (vtArgType & VT_BYREF);
#else
#error Unknown platform
#endif
VARTYPE vtConversionType = vtArgType & VT_TYPEMASK;
if (vtArgType & VT_ARRAY) {
SAFEARRAY FAR *psa = *((SAFEARRAY **)pb);
if (psa==NULL) { // A NULL array
Py_INCREF(Py_None);
obArg = Py_None;
} else {
if (vtArgType & VT_BYREF) // one more level of indirection
psa = *((SAFEARRAY FAR **)psa);
if (psa==NULL) { // A NULL array
Py_INCREF(Py_None);
obArg = Py_None;
} else
obArg = PyCom_PyObjectFromSAFEARRAY(psa, (VARENUM)vtConversionType);
}
} else {
switch (vtConversionType)
{
// If they can fit in a VARIANT, cheat and make that code do all of the work...
case VT_I2:
case VT_I4:
case VT_R4:
case VT_R8:
case VT_CY:
case VT_DATE:
case VT_BSTR:
case VT_ERROR:
case VT_BOOL:
case VT_I1:
case VT_UI1:
case VT_UI2:
case VT_UI4:
case VT_INT:
case VT_UINT:
case VT_UNKNOWN:
case VT_DISPATCH:
case VT_HRESULT:
VariantInit(&var);
if (vtConversionType == VT_HRESULT ||
vtConversionType == VT_INT)
//.........这里部分代码省略.........
示例3: pyqtSignal_init
//.........这里部分代码省略.........
{
PyErr_Format(PyExc_TypeError,
"signal 'attribute_names' must be a sequence of str, not %s",
sipPyTypeName(Py_TYPE(value)));
if (parameter_names)
delete parameter_names;
Py_XDECREF(name_obj);
return -1;
}
}
else
{
#if PY_MAJOR_VERSION >= 3
PyErr_Format(PyExc_TypeError,
"pyqtSignal() got an unexpected keyword argument '%U'",
key);
#else
PyErr_Format(PyExc_TypeError,
"pyqtSignal() got an unexpected keyword argument '%s'",
PyString_AsString(key));
#endif
Py_XDECREF(name_obj);
return -1;
}
}
}
// If there is at least one argument and it is a sequence then assume all
// arguments are sequences. Unfortunately a string is also a sequence so
// check for tuples and lists explicitly.
if (PyTuple_Size(args) > 0 && (PyTuple_Check(PyTuple_GetItem(args, 0)) || PyList_Check(PyTuple_GetItem(args, 0))))
{
for (Py_ssize_t i = 0; i < PyTuple_Size(args); ++i)
{
PyObject *types = PySequence_Tuple(PyTuple_GetItem(args, i));
if (!types)
{
PyErr_SetString(PyExc_TypeError,
"pyqtSignal() argument expected to be sequence of types");
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
int rc;
if (i == 0)
{
// The first is the default.
rc = init_signal_from_types(ps, name, parameter_names,
revision, types);
}
else
{
qpycore_pyqtSignal *overload = (qpycore_pyqtSignal *)PyType_GenericNew(qpycore_pyqtSignal_TypeObject, 0, 0);
if (!overload)
{
示例4: AerospikeScan_Select
AerospikeScan * AerospikeScan_Select(AerospikeScan * self, PyObject * args, PyObject * kwds)
{
TRACE();
char * bin = NULL;
PyObject * py_ustr = NULL;
as_error err;
as_error_init(&err);
if (!self || !self->client->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
int nbins = (int) PyTuple_Size(args);
as_scan_select_init(&self->scan, nbins);
for ( int i = 0; i < nbins; i++ ) {
PyObject * py_bin = PyTuple_GetItem(args, i);
if ( py_bin) {
TRACE();
if (PyUnicode_Check(py_bin)) {
py_ustr = PyUnicode_AsUTF8String(py_bin);
bin = PyString_AsString(py_ustr);
} else if (PyString_Check(py_bin)) {
bin = PyString_AsString(py_bin);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Bin name should be of type string");
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
} else {
TRACE();
}
as_scan_select(&self->scan, bin);
if (py_ustr) {
Py_DECREF(py_ustr);
py_ustr = NULL;
}
}
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
Py_INCREF(self);
return self;
}
示例5: PyErr_Format
// The type call slot.
static PyObject *pyqtMethodProxy_call(PyObject *self, PyObject *args,
PyObject *kw_args)
{
qpycore_pyqtMethodProxy *mp = (qpycore_pyqtMethodProxy *)self;
const char *py_name = mp->py_name->constData();
// Check for keyword arguments.
if (kw_args)
{
PyErr_Format(PyExc_TypeError,
"%s() does not support keyword arguments", py_name);
return 0;
}
QMetaMethod method = mp->qobject->metaObject()->method(mp->method_index);
QList<QByteArray> arg_types = method.parameterTypes();
if (PyTuple_Size(args) != arg_types.size())
{
PyErr_Format(PyExc_TypeError,
#if PY_VERSION_HEX >= 0x02050000
"%s() called with %zd arguments but %d expected",
#else
"%s() called with %d arguments but %d expected",
#endif
py_name, PyTuple_Size(args), arg_types.size());
return 0;
}
// Parse the return type and the arguments.
QGenericReturnArgument ret;
QGenericArgument a0, a1, a2, a3, a4, a5, a6, a7, a8, a9;
Chimera::Storage *return_storage, *storage[10];
QByteArray return_type(method.typeName());
bool failed = false;
return_storage = 0;
if (!return_type.isEmpty())
{
const Chimera *ct = Chimera::parse(return_type);
if (!ct)
{
PyErr_Format(PyExc_TypeError,
"unable to convert return value of %s from '%s' to a Python object",
py_name, return_type.constData());
return 0;
}
return_storage = ct->storageFactory();
ret = QGenericReturnArgument(return_type.constData(),
return_storage->address());
}
parse_arg(args, 0, arg_types, a0, storage, failed, py_name);
parse_arg(args, 1, arg_types, a1, storage, failed, py_name);
parse_arg(args, 2, arg_types, a2, storage, failed, py_name);
parse_arg(args, 3, arg_types, a3, storage, failed, py_name);
parse_arg(args, 4, arg_types, a4, storage, failed, py_name);
parse_arg(args, 5, arg_types, a5, storage, failed, py_name);
parse_arg(args, 6, arg_types, a6, storage, failed, py_name);
parse_arg(args, 7, arg_types, a7, storage, failed, py_name);
parse_arg(args, 8, arg_types, a8, storage, failed, py_name);
parse_arg(args, 9, arg_types, a9, storage, failed, py_name);
// Invoke the method.
PyObject *result = 0;
if (!failed)
{
#if QT_VERSION >= 0x040500
failed = !method.invoke(mp->qobject, ret, a0, a1, a2, a3, a4, a5, a6,
a7, a8, a9);
#else
// Get the method name.
QByteArray mname(method.signature());
mname.truncate(mname.indexOf('('));
failed = !QMetaObject::invokeMethod(mp->qobject, mname.constData(),
ret, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
#endif
if (failed)
{
PyErr_Format(PyExc_TypeError, "invocation of %s() failed", py_name);
}
else if (return_storage)
{
result = return_storage->toPyObject();
}
else
{
result = Py_None;
Py_INCREF(result);
}
}
//.........这里部分代码省略.........
示例6: PyErr_SetString
static PyObject *py_sorted_tree_items(PyObject *self, PyObject *entries)
{
struct tree_item *qsort_entries;
int num, i;
PyObject *ret;
Py_ssize_t pos = 0;
PyObject *key, *value;
if (!PyDict_Check(entries)) {
PyErr_SetString(PyExc_TypeError, "Argument not a dictionary");
return NULL;
}
num = PyDict_Size(entries);
qsort_entries = malloc(num * sizeof(struct tree_item));
if (qsort_entries == NULL) {
PyErr_NoMemory();
return NULL;
}
i = 0;
while (PyDict_Next(entries, &pos, &key, &value)) {
PyObject *py_mode, *py_sha;
if (PyTuple_Size(value) != 2) {
PyErr_SetString(PyExc_ValueError, "Tuple has invalid size");
free(qsort_entries);
return NULL;
}
py_mode = PyTuple_GET_ITEM(value, 0);
py_sha = PyTuple_GET_ITEM(value, 1);
qsort_entries[i].tuple = Py_BuildValue("(OOO)", key, py_mode, py_sha);
if (!PyString_CheckExact(key)) {
PyErr_SetString(PyExc_TypeError, "Name is not a string");
free(qsort_entries);
return NULL;
}
qsort_entries[i].name = PyString_AS_STRING(key);
if (!PyInt_CheckExact(py_mode)) {
PyErr_SetString(PyExc_TypeError, "Mode is not an int");
free(qsort_entries);
return NULL;
}
qsort_entries[i].mode = PyInt_AS_LONG(py_mode);
i++;
}
qsort(qsort_entries, num, sizeof(struct tree_item), cmp_tree_item);
ret = PyList_New(num);
if (ret == NULL) {
free(qsort_entries);
PyErr_NoMemory();
return NULL;
}
for (i = 0; i < num; i++) {
PyList_SET_ITEM(ret, i, qsort_entries[i].tuple);
}
free(qsort_entries);
return ret;
}
示例7: find_method
// find and call a method on this object that matches the python args.
// typically called by way of pyjmethod when python invokes __call__.
//
// steals reference to self, methodname and args.
PyObject* find_method(JNIEnv *env,
PyObject *methodName,
Py_ssize_t methodCount,
PyObject *attr,
PyObject *args) {
// all possible method candidates
PyJmethod_Object **cand = NULL;
Py_ssize_t pos, i, listSize, argsSize;
pos = i = listSize = argsSize = 0;
// not really likely if we were called from pyjmethod, but hey...
if(methodCount < 1) {
PyErr_Format(PyExc_RuntimeError, "I have no methods.");
return NULL;
}
if(!attr || !PyList_CheckExact(attr)) {
PyErr_Format(PyExc_RuntimeError, "Invalid attr list.");
return NULL;
}
cand = (PyJmethod_Object **)
PyMem_Malloc(sizeof(PyJmethod_Object*) * methodCount);
// just for safety
for(i = 0; i < methodCount; i++)
cand[i] = NULL;
listSize = PyList_GET_SIZE(attr);
for(i = 0; i < listSize; i++) {
PyObject *tuple = PyList_GetItem(attr, i); /* borrowed */
if(PyErr_Occurred())
break;
if(!tuple || tuple == Py_None || !PyTuple_CheckExact(tuple))
continue;
if(PyTuple_Size(tuple) == 2) {
PyObject *key = PyTuple_GetItem(tuple, 0); /* borrowed */
if(PyErr_Occurred())
break;
if(!key || !PyString_Check(key))
continue;
if(PyObject_Compare(key, methodName) == 0) {
PyObject *method = PyTuple_GetItem(tuple, 1); /* borrowed */
if(pyjmethod_check(method))
cand[pos++] = (PyJmethod_Object *) method;
}
}
}
if(PyErr_Occurred())
goto EXIT_ERROR;
// makes more sense to work with...
pos--;
if(pos < 0) {
// didn't find a method by that name....
// that shouldn't happen unless the search above is broken.
PyErr_Format(PyExc_NameError, "No such method.");
goto EXIT_ERROR;
}
if(pos == 0) {
// we're done, call that one
PyObject *ret = pyjmethod_call_internal(cand[0], args);
PyMem_Free(cand);
return ret;
}
// first, find out if there's only one method that
// has the correct number of args
argsSize = PyTuple_Size(args);
{
PyJmethod_Object *matching = NULL;
int count = 0;
for(i = 0; i <= pos && cand[i]; i++) {
// make sure method is fully initialized
if(!cand[i]->parameters) {
if(!pyjmethod_init(env, cand[i])) {
// init failed, that's not good.
cand[i] = NULL;
PyErr_Warn(PyExc_Warning, "pyjmethod init failed.");
continue;
}
}
if(cand[i]->lenParameters == argsSize) {
matching = cand[i];
count++;
//.........这里部分代码省略.........
示例8: noteq_init
static PyObject *cboodle_init(PyObject *self, PyObject *args)
{
char *devname = NULL;
int ratewanted = 0;
int verbose = 0;
int ix, res;
PyObject *extras = NULL;
extraopt_t *opts = NULL;
extraopt_t dummyopt = {NULL, NULL};
if (!PyArg_ParseTuple(args, "|ziiO:init", &devname, &ratewanted, &verbose, &extras))
return NULL;
res = noteq_init();
if (!res) {
PyErr_SetString(PyExc_IOError, "unable to initialize note queue");
return NULL;
}
if (extras && PyList_Check(extras)) {
int count = PyList_Size(extras);
opts = (extraopt_t *)malloc(sizeof(extraopt_t) * (count+1));
if (!opts) {
PyErr_SetString(PyExc_IOError, "unable to initialize extra options");
return NULL;
}
for (ix=0; ix<count; ix++) {
PyObject *tup = PyList_GetItem(extras, ix);
PyObject *tkey, *tval;
if (!tup)
return NULL;
if (!PyTuple_Check(tup) || PyTuple_Size(tup) != 2) {
PyErr_SetString(PyExc_TypeError, "extraopts must be a list of 2-tuples");
return NULL;
}
tkey = PyTuple_GetItem(tup, 0);
if (!tkey)
return NULL;
tval = PyTuple_GetItem(tup, 1);
if (!tval)
return NULL;
if (!PyString_Check(tkey)
|| !(tval == Py_None || PyString_Check(tval))) {
PyErr_SetString(PyExc_TypeError, "extraopts must be (string, string) or (string, None)");
return NULL;
}
opts[ix].key = PyString_AsString(tkey);
if (tval == Py_None)
opts[ix].val = NULL;
else
opts[ix].val = PyString_AsString(tval);
}
opts[count].key = NULL;
opts[count].val = NULL;
}
res = audev_init_device(devname, ratewanted, (verbose!=0),
(opts?opts:(&dummyopt)));
if (!res) {
PyErr_SetString(PyExc_IOError, "unable to initialize audio device");
if (opts) {
free(opts);
}
return NULL;
}
if (opts) {
free(opts);
}
Py_INCREF(Py_None);
return Py_None;
}
示例9: pygrpc_produce_op
int pygrpc_produce_op(PyObject *op, grpc_op *result) {
static const int OP_TUPLE_SIZE = 6;
static const int STATUS_TUPLE_SIZE = 2;
static const int TYPE_INDEX = 0;
static const int INITIAL_METADATA_INDEX = 1;
static const int TRAILING_METADATA_INDEX = 2;
static const int MESSAGE_INDEX = 3;
static const int STATUS_INDEX = 4;
static const int STATUS_CODE_INDEX = 0;
static const int STATUS_DETAILS_INDEX = 1;
static const int WRITE_FLAGS_INDEX = 5;
int type;
Py_ssize_t message_size;
char *message;
char *status_details;
gpr_slice message_slice;
grpc_op c_op;
if (!PyTuple_Check(op)) {
PyErr_SetString(PyExc_TypeError, "expected tuple op");
return 0;
}
if (PyTuple_Size(op) != OP_TUPLE_SIZE) {
char *buf;
gpr_asprintf(&buf, "expected tuple op of length %d", OP_TUPLE_SIZE);
PyErr_SetString(PyExc_ValueError, buf);
gpr_free(buf);
return 0;
}
type = PyInt_AsLong(PyTuple_GET_ITEM(op, TYPE_INDEX));
if (PyErr_Occurred()) {
return 0;
}
c_op.op = type;
c_op.flags = PyInt_AsLong(PyTuple_GET_ITEM(op, WRITE_FLAGS_INDEX));
if (PyErr_Occurred()) {
return 0;
}
switch (type) {
case GRPC_OP_SEND_INITIAL_METADATA:
if (!pygrpc_cast_pyseq_to_send_metadata(
PyTuple_GetItem(op, INITIAL_METADATA_INDEX),
&c_op.data.send_initial_metadata.metadata,
&c_op.data.send_initial_metadata.count)) {
return 0;
}
break;
case GRPC_OP_SEND_MESSAGE:
PyString_AsStringAndSize(
PyTuple_GET_ITEM(op, MESSAGE_INDEX), &message, &message_size);
message_slice = gpr_slice_from_copied_buffer(message, message_size);
c_op.data.send_message = grpc_raw_byte_buffer_create(&message_slice, 1);
gpr_slice_unref(message_slice);
break;
case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
/* Don't need to fill in any other fields. */
break;
case GRPC_OP_SEND_STATUS_FROM_SERVER:
if (!pygrpc_cast_pyseq_to_send_metadata(
PyTuple_GetItem(op, TRAILING_METADATA_INDEX),
&c_op.data.send_status_from_server.trailing_metadata,
&c_op.data.send_status_from_server.trailing_metadata_count)) {
return 0;
}
if (!PyTuple_Check(PyTuple_GET_ITEM(op, STATUS_INDEX))) {
char *buf;
gpr_asprintf(&buf, "expected tuple status in op of length %d",
STATUS_TUPLE_SIZE);
PyErr_SetString(PyExc_ValueError, buf);
gpr_free(buf);
return 0;
}
c_op.data.send_status_from_server.status = PyInt_AsLong(
PyTuple_GET_ITEM(PyTuple_GET_ITEM(op, STATUS_INDEX), STATUS_CODE_INDEX));
status_details = PyString_AsString(
PyTuple_GET_ITEM(PyTuple_GET_ITEM(op, STATUS_INDEX), STATUS_DETAILS_INDEX));
if (PyErr_Occurred()) {
return 0;
}
c_op.data.send_status_from_server.status_details =
gpr_malloc(strlen(status_details) + 1);
strcpy((char *)c_op.data.send_status_from_server.status_details,
status_details);
break;
case GRPC_OP_RECV_INITIAL_METADATA:
c_op.data.recv_initial_metadata = gpr_malloc(sizeof(grpc_metadata_array));
grpc_metadata_array_init(c_op.data.recv_initial_metadata);
break;
case GRPC_OP_RECV_MESSAGE:
c_op.data.recv_message = gpr_malloc(sizeof(grpc_byte_buffer *));
break;
case GRPC_OP_RECV_STATUS_ON_CLIENT:
c_op.data.recv_status_on_client.trailing_metadata =
gpr_malloc(sizeof(grpc_metadata_array));
grpc_metadata_array_init(c_op.data.recv_status_on_client.trailing_metadata);
c_op.data.recv_status_on_client.status =
gpr_malloc(sizeof(grpc_status_code *));
c_op.data.recv_status_on_client.status_details =
gpr_malloc(sizeof(char *));
*c_op.data.recv_status_on_client.status_details = NULL;
c_op.data.recv_status_on_client.status_details_capacity =
//.........这里部分代码省略.........
示例10: obexserver_notifynewrequest
/*
Returns new reference that must be decref'd.
*/
static PyObject*
obexserver_notifynewrequest(OBEXServer *self, obex_object_t *obj, int obex_cmd, int *respcode)
{
PyObject *resp;
PyObject *respheaders;
PyObject *tmpfileobj;
PyObject *reqheaders;
int nonhdrdata_len;
PyObject *nonhdrdata_obj;
uint8_t *nonhdrdata;
DEBUG("%s() cmd=%d\n", __func__, obex_cmd);
if (self->notifiednewrequest) {
DEBUG("\tAlready called cb_newrequest");
return NULL;
}
if (self->cb_newrequest == NULL) { /* shouldn't happen */
obexserver_errorstr(self, PyExc_IOError, "cb_newrequest is NULL");
return NULL;
}
reqheaders = lightblueobex_readheaders(self->obex, obj);
if (reqheaders == NULL) {
obexserver_errorstr(self, PyExc_IOError,
"error reading request headers");
return NULL;
}
nonhdrdata_len = OBEX_ObjectGetNonHdrData(obj, &nonhdrdata);
if (nonhdrdata_len < 0) {
obexserver_errorstr(self, PyExc_IOError,
"error reading non-header data");
return NULL;
}
nonhdrdata_obj = PyBuffer_FromMemory(nonhdrdata,
(Py_ssize_t)nonhdrdata_len);
if (nonhdrdata_obj == NULL) {
obexserver_errorstr(self, PyExc_IOError,
"error reading non-header buffer");
return NULL;
}
resp = PyObject_CallFunction(self->cb_newrequest, "iOOO",
obex_cmd, reqheaders, nonhdrdata_obj,
(self->hasbodydata ? Py_True : Py_False));
Py_DECREF(nonhdrdata_obj);
self->notifiednewrequest = 1;
if (resp == NULL) {
DEBUG("\terror calling cb_newrequest\n");
obexserver_errorfetch(self);
return NULL;
}
if ( !PyTuple_Check(resp) || PyTuple_Size(resp) < 3 ||
!PyInt_Check(PyTuple_GetItem(resp, 0)) ||
!PyDict_Check(PyTuple_GetItem(resp, 1)) ) {
obexserver_errorstr(self, PyExc_TypeError,
"callback must return (int, dict, fileobj | None) tuple");
return NULL;
}
tmpfileobj = PyTuple_GetItem(resp, 2);
if (obex_cmd == OBEX_CMD_PUT && self->hasbodydata &&
!PyObject_HasAttrString(tmpfileobj, "write")) {
obexserver_errorstr(self, PyExc_ValueError,
"specified file object does not have 'write' method for Put request");
return NULL;
}
if (obex_cmd == OBEX_CMD_GET &&
!PyObject_HasAttrString(tmpfileobj, "read")) {
obexserver_errorstr(self, PyExc_ValueError,
"specified file object does not have 'read' method for Get request");
return NULL;
}
*respcode = PyInt_AsLong(PyTuple_GetItem(resp, 0));
if (PyErr_Occurred()) {
PyErr_Clear();
obexserver_errorstr(self, PyExc_IOError,
"error reading returned response code");
return NULL;
}
Py_XDECREF(self->fileobj);
Py_INCREF(tmpfileobj);
self->fileobj = tmpfileobj;
respheaders = PyTuple_GetItem(resp, 1);
Py_INCREF(respheaders);
return respheaders;
//.........这里部分代码省略.........
示例11: AerospikeClient_Select_Many_Invoke
/**
*********************************************************************
* This function will invoke aerospike_batch_get_bins to get filtered
* bins from all the records in a batches.
*
* @param self AerospikeClient object
* @param py_keys List of keys passed on by user
* @param py_bins List of filter bins passed on by user
* @param py_policy User specified Policy dictionary
*
*********************************************************************
**/
static
PyObject * AerospikeClient_Select_Many_Invoke(
AerospikeClient * self,
PyObject * py_keys, PyObject * py_bins, PyObject * py_policy)
{
// Python Return Value
PyObject * py_recs = NULL;
// Aerospike Client Arguments
as_error err;
as_policy_batch policy;
as_policy_batch * batch_policy_p = NULL;
Py_ssize_t bins_size = 0;
char **filter_bins = NULL;
bool has_batch_index = false;
// Unicode object's pool
UnicodePyObjects u_objs;
u_objs.size = 0;
int i = 0;
// Initialize error
as_error_init(&err);
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Check the type of bins and get it's size
// i.e. number of bins provided
if (py_bins != NULL && PyList_Check(py_bins)) {
bins_size = PyList_Size(py_bins);
}
else if (py_bins != NULL && PyTuple_Check(py_bins)) {
bins_size = PyTuple_Size(py_bins);
}
else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Filter bins should be specified as a list or tuple.");
goto CLEANUP;
}
filter_bins = (char **)malloc(sizeof(long int) * bins_size);
for (i = 0; i < bins_size; i++) {
PyObject *py_bin = NULL;
if(PyList_Check(py_bins)) {
py_bin = PyList_GetItem(py_bins, i);
}
if(PyTuple_Check(py_bins)) {
py_bin = PyTuple_GetItem(py_bins, i);
}
if (PyUnicode_Check(py_bin)) {
// Store the unicode object into a pool
// It is DECREFed at later stages
// So, no need of DECREF here.
filter_bins[i] = PyStr_AsString(
store_unicode_bins(&u_objs, PyUnicode_AsUTF8String(py_bin)));
}
else if (PyStr_Check(py_bin)) {
filter_bins[i] = PyStr_AsString(py_bin);
}
else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Bin name should be a string or unicode string.");
goto CLEANUP;
}
}
// Convert python policy object to as_policy_batch
pyobject_to_policy_batch(&err, py_policy, &policy, &batch_policy_p,
&self->as->config.policies.batch);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
has_batch_index = aerospike_has_batch_index(self->as);
if (has_batch_index) {
py_recs = batch_select_aerospike_batch_read(&err, self, py_keys, batch_policy_p, filter_bins, bins_size);
} else {
py_recs = batch_select_aerospike_batch_get(&err, self, py_keys, batch_policy_p, filter_bins, bins_size);
}
CLEANUP:
//.........这里部分代码省略.........
示例12: batch_select_aerospike_batch_get
/**
*******************************************************************************************************
* This function will get a batch of records from the Aeropike DB.
*
* @param err as_error object
* @param self AerospikeClient object
* @param py_keys The list of keys
* @param batch_policy_p as_policy_batch object
*
* Returns the record if key exists otherwise NULL.
*******************************************************************************************************
*/
static PyObject * batch_select_aerospike_batch_get(as_error *err, AerospikeClient * self, PyObject *py_keys, as_policy_batch * batch_policy_p, char **filter_bins, Py_ssize_t bins_size)
{
PyObject * py_recs = NULL;
as_batch batch;
bool batch_initialised = false;
// Convert python keys list to as_key ** and add it to as_batch.keys
// keys can be specified in PyList or PyTuple
if ( py_keys != NULL && PyList_Check(py_keys) ) {
Py_ssize_t size = PyList_Size(py_keys);
py_recs = PyList_New(size);
as_batch_init(&batch, size);
// Batch object initialised
batch_initialised = true;
for ( int i = 0; i < size; i++ ) {
PyObject * py_key = PyList_GetItem(py_keys, i);
if ( !PyTuple_Check(py_key) ) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Key should be a tuple.");
goto CLEANUP;
}
pyobject_to_key(err, py_key, as_batch_keyat(&batch, i));
if ( err->code != AEROSPIKE_OK ) {
goto CLEANUP;
}
}
}
else if ( py_keys != NULL && PyTuple_Check(py_keys) ) {
Py_ssize_t size = PyTuple_Size(py_keys);
py_recs = PyList_New(size);
as_batch_init(&batch, size);
// Batch object initialised
batch_initialised = true;
for ( int i = 0; i < size; i++ ) {
PyObject * py_key = PyTuple_GetItem(py_keys, i);
if ( !PyTuple_Check(py_key) ) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Key should be a tuple.");
goto CLEANUP;
}
pyobject_to_key(err, py_key, as_batch_keyat(&batch, i));
if ( err->code != AEROSPIKE_OK ) {
goto CLEANUP;
}
}
}
else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Keys should be specified as a list or tuple.");
goto CLEANUP;
}
// Invoke C-client API
aerospike_batch_get_bins(self->as, err, batch_policy_p,
&batch, (const char **) filter_bins, bins_size,
(aerospike_batch_read_callback) batch_select_cb,
py_recs);
CLEANUP:
if (batch_initialised == true) {
// We should destroy batch object as we are using 'as_batch_init' for initialisation
// Also, pyobject_to_key is soing strdup() in case of Unicode. So, object destruction
// is necessary.
as_batch_destroy(&batch);
}
return py_recs;
}
示例13: batch_select_aerospike_batch_read
/**
*******************************************************************************************************
* This function will get a batch of records from the Aeropike DB.
*
* @param err as_error object
* @param self AerospikeClient object
* @param py_keys The list of keys
* @param batch_policy_p as_policy_batch object
*
* Returns the record if key exists otherwise NULL.
*******************************************************************************************************
*/
static PyObject * batch_select_aerospike_batch_read(as_error *err, AerospikeClient * self, PyObject *py_keys, as_policy_batch * batch_policy_p, char** filter_bins, Py_ssize_t bins_size)
{
PyObject * py_recs = NULL;
as_batch_read_records records;
as_batch_read_record* record = NULL;
bool batch_initialised = false;
// Convert python keys list to as_key ** and add it to as_batch.keys
// keys can be specified in PyList or PyTuple
if ( py_keys != NULL && PyList_Check(py_keys) ) {
Py_ssize_t size = PyList_Size(py_keys);
py_recs = PyList_New(size);
as_batch_read_inita(&records, size);
// Batch object initialised
batch_initialised = true;
for ( int i = 0; i < size; i++ ) {
PyObject * py_key = PyList_GetItem(py_keys, i);
if ( !PyTuple_Check(py_key) ) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Key should be a tuple.");
goto CLEANUP;
}
record = as_batch_read_reserve(&records);
pyobject_to_key(err, py_key, &record->key);
if (bins_size) {
record->bin_names = filter_bins;
record->n_bin_names = bins_size;
} else {
record->read_all_bins = true;
}
if ( err->code != AEROSPIKE_OK ) {
goto CLEANUP;
}
}
}
else if ( py_keys != NULL && PyTuple_Check(py_keys) ) {
Py_ssize_t size = PyTuple_Size(py_keys);
py_recs = PyList_New(size);
as_batch_read_inita(&records, size);
// Batch object initialised
batch_initialised = true;
for ( int i = 0; i < size; i++ ) {
PyObject * py_key = PyTuple_GetItem(py_keys, i);
if ( !PyTuple_Check(py_key) ) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Key should be a tuple.");
goto CLEANUP;
}
record = as_batch_read_reserve(&records);
pyobject_to_key(err, py_key, &record->key);
if (bins_size) {
record->bin_names = filter_bins;
record->n_bin_names = bins_size;
} else {
record->read_all_bins = true;
}
if ( err->code != AEROSPIKE_OK ) {
goto CLEANUP;
}
}
}
else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Keys should be specified as a list or tuple.");
goto CLEANUP;
}
// Invoke C-client API
if (aerospike_batch_read(self->as, err, batch_policy_p, &records) != AEROSPIKE_OK)
{
goto CLEANUP;
}
batch_select_recs(err, &records, &py_recs);
CLEANUP:
//.........这里部分代码省略.........
示例14: pyg_flags_get_value
/**
* pyg_flags_get_value:
* @flag_type: the GType of the flag.
* @obj: a Python object representing the flag value
* @val: a pointer to the location to store the integer representation of the flag.
*
* Converts a Python object to the integer equivalent. The conversion
* will depend on the type of the Python object. If the object is an
* integer, it is passed through directly. If it is a string, it will
* be treated as a full or short flag name as defined in the GType.
* If it is a tuple, then the items are treated as strings and ORed
* together.
*
* Returns: 0 on success or -1 on failure
*/
gint
pyg_flags_get_value(GType flag_type, PyObject *obj, gint *val)
{
GFlagsClass *fclass = NULL;
gint res = -1;
g_return_val_if_fail(val != NULL, -1);
if (!obj) {
*val = 0;
res = 0;
} else if (PYGLIB_PyLong_Check(obj)) {
*val = PYGLIB_PyLong_AsLong(obj);
res = 0;
} else if (PyLong_Check(obj)) {
*val = PyLong_AsLongLong(obj);
res = 0;
} else if (PYGLIB_PyUnicode_Check(obj)) {
GFlagsValue *info;
char *str = PYGLIB_PyUnicode_AsString(obj);
if (flag_type != G_TYPE_NONE)
fclass = G_FLAGS_CLASS(g_type_class_ref(flag_type));
else {
PyErr_SetString(PyExc_TypeError, "could not convert string to flag because there is no GType associated to look up the value");
res = -1;
}
info = g_flags_get_value_by_name(fclass, str);
g_type_class_unref(fclass);
if (!info)
info = g_flags_get_value_by_nick(fclass, str);
if (info) {
*val = info->value;
res = 0;
} else {
PyErr_SetString(PyExc_TypeError, "could not convert string");
res = -1;
}
} else if (PyTuple_Check(obj)) {
int i, len;
len = PyTuple_Size(obj);
*val = 0;
res = 0;
if (flag_type != G_TYPE_NONE)
fclass = G_FLAGS_CLASS(g_type_class_ref(flag_type));
else {
PyErr_SetString(PyExc_TypeError, "could not convert string to flag because there is no GType associated to look up the value");
res = -1;
}
for (i = 0; i < len; i++) {
PyObject *item = PyTuple_GetItem(obj, i);
char *str = PYGLIB_PyUnicode_AsString(item);
GFlagsValue *info = g_flags_get_value_by_name(fclass, str);
if (!info)
info = g_flags_get_value_by_nick(fclass, str);
if (info) {
*val |= info->value;
} else {
PyErr_SetString(PyExc_TypeError, "could not convert string");
res = -1;
break;
}
}
g_type_class_unref(fclass);
} else {
PyErr_SetString(PyExc_TypeError,
"flag values must be strings, ints, longs, or tuples");
res = -1;
}
return res;
}
示例15: _same_vals_helper
static int
_same_vals_helper(PyObject *v1, PyObject *v2)
{
PyTypeObject *typ1, *typ2;
if (v1 == v2) return 0; // 0 -> items are equal
typ1 = v1->ob_type;
typ2 = v2->ob_type;
if (typ1 != typ2) return 1;
if (typ1 == &PyDict_Type) {
PyObject *key;
PyObject *value;
XXX_Py_ssize_t pos = 0;
if (PyDict_Size(v1) != PyDict_Size(v2)) {
return 1;
}
while (PyDict_Next(v1, &pos, &key, &value)) {
// note: when compiling the above line I get the following warning, hopefully harmless:
// samevalshelp.c:49: warning: passing argument 2 of ‘PyDict_Next’ from incompatible pointer type
// [bruce 090206, compiling on Mac OS 10.5.6, pyrexc version 0.9.6.4]
PyObject *value2 = PyDict_GetItem(v2, key);
if (value2 == NULL) {
return 1;
}
if (_same_vals_helper(value, value2)) {
return 1;
}
}
return 0;
} else if (typ1 == &PyList_Type) {
int i, n;
n = PyList_Size(v1);
if (n != PyList_Size(v2)) {
return 1;
}
for (i = 0; i < n; i++)
if (_same_vals_helper(PyList_GetItem(v1, i),
PyList_GetItem(v2, i)))
return 1;
return 0;
} else if (typ1 == &PyTuple_Type) {
int i, n;
n = PyTuple_Size(v1);
if (n != PyTuple_Size(v2)) {
return 1;
}
for (i = 0; i < n; i++)
if (_same_vals_helper(PyTuple_GetItem(v1, i),
PyTuple_GetItem(v2, i)))
return 1;
return 0;
} else if (arrayType != NULL && typ1 == arrayType) {
PyArrayObject *x = (PyArrayObject *) v1;
PyArrayObject *y = (PyArrayObject *) v2;
int i;
int elementSize;
int *indices;
int topDimension;
char *xdata;
char *ydata;
int objectCompare = 0;
// do all quick rejects first (no loops)
if (x->nd != y->nd) {
// number of dimensions doesn't match
return 1;
// note that a (1 x X) array can never equal a single
// dimensional array of length X.
}
if (x->descr->type_num != y->descr->type_num) {
// type of elements doesn't match
return 1;
}
if (x->descr->type_num == PyArray_OBJECT) {
objectCompare = 1;
}
elementSize = x->descr->elsize;
if (elementSize != y->descr->elsize) {
// size of elements doesn't match (shouldn't happen if
// types match!)
return 1;
}
for (i = x->nd - 1; i >= 0; i--) {
if (x->dimensions[i] != y->dimensions[i])
// shapes don't match
return 1;
}
// we do a lot of these, so handle them early
if (x->nd == 1 && !objectCompare && x->strides[0]==elementSize && y->strides[0]==elementSize) {
// contiguous one dimensional array of non-objects
return memcmp(x->data, y->data, elementSize * x->dimensions[0]) ? 1 : 0;
}
if (x->nd == 0) {
// scalar, just compare one element
if (objectCompare) {
return _same_vals_helper(*(PyObject **)x->data, *(PyObject **)y->data);
} else {
return memcmp(x->data, y->data, elementSize) ? 1 : 0;
//.........这里部分代码省略.........