static PyObject *
int_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyObject *x = NULL;
int base = -909;
static char *kwlist[] = {"x", "base", 0};
if (type != &PyInt_Type)
return int_subtype_new(type, args, kwds); /* Wimp out */
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:int", kwlist,
&x, &base))
return NULL;
if (x == NULL)
return PyInt_FromLong(0L);
if (base == -909)
return PyNumber_Int(x);
if (PyString_Check(x))
return PyInt_FromString(PyString_AS_STRING(x), NULL, base);
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(x))
return PyInt_FromUnicode(PyUnicode_AS_UNICODE(x),
PyUnicode_GET_SIZE(x),
base);
#endif
PyErr_SetString(PyExc_TypeError,
"int() can't convert non-string with explicit base");
return NULL;
}
PyObject* integer_to_PyInt(const lp_integer_t* x) {
char* str = lp_integer_to_string(x);
char* str_p = 0;
PyObject* result = PyInt_FromString(str, &str_p, 10);
free(str);
return result;
}
static Box* _intNew(Box* val, Box* base) {
if (isSubclass(val->cls, int_cls)) {
RELEASE_ASSERT(!base, "");
BoxedInt* n = static_cast<BoxedInt*>(val);
if (val->cls == int_cls)
return n;
return new BoxedInt(n->n);
} else if (isSubclass(val->cls, str_cls)) {
int base_n;
if (!base)
base_n = 10;
else {
RELEASE_ASSERT(base->cls == int_cls, "");
base_n = static_cast<BoxedInt*>(base)->n;
}
BoxedString* s = static_cast<BoxedString*>(val);
RELEASE_ASSERT(s->size() == strlen(s->data()), "");
Box* r = PyInt_FromString(s->data(), NULL, base_n);
if (!r)
throwCAPIException();
return r;
} else if (isSubclass(val->cls, unicode_cls)) {
int base_n;
if (!base)
base_n = 10;
else {
RELEASE_ASSERT(base->cls == int_cls, "");
base_n = static_cast<BoxedInt*>(base)->n;
}
Box* r = PyInt_FromUnicode(PyUnicode_AS_UNICODE(val), PyUnicode_GET_SIZE(val), base_n);
if (!r)
throwCAPIException();
return r;
} else if (val->cls == float_cls) {
RELEASE_ASSERT(!base, "");
double d = static_cast<BoxedFloat*>(val)->d;
return new BoxedInt(d);
} else {
RELEASE_ASSERT(!base, "");
static const std::string int_str("__int__");
Box* r = callattr(val, &int_str, CallattrFlags({.cls_only = true, .null_on_nonexistent = true }),
ArgPassSpec(0), NULL, NULL, NULL, NULL, NULL);
if (!r) {
fprintf(stderr, "TypeError: int() argument must be a string or a number, not '%s'\n", getTypeName(val));
raiseExcHelper(TypeError, "");
}
if (!isSubclass(r->cls, int_cls) && !isSubclass(r->cls, long_cls)) {
raiseExcHelper(TypeError, "__int__ returned non-int (type %s)", r->cls->tp_name);
}
return r;
}
static PyObject *
typecast_INTEGER_cast(const char *s, Py_ssize_t len, PyObject *curs)
{
char buffer[12];
if (s == NULL) {Py_INCREF(Py_None); return Py_None;}
if (s[len] != '\0') {
strncpy(buffer, s, (size_t) len); buffer[len] = '\0';
s = buffer;
}
return PyInt_FromString((char *)s, NULL, 0);
}
static PyObject *
GPIO_get_value(GPIO * self) {
int dirfd;
char cval[2];
PyObject * i;
getl(self->fd_val, &cval[0]);
i = PyInt_FromString(&cval[0], NULL, 10);
// printf("\nget_value() returning %i (%i)\n", cval[0] - 48, PyInt_AsLong(i));
return i;
}
static PyObject *
PWM_get_period(PWM * self) {
char cprd[10];
PyObject * i;
getl(self->fd_period, &cprd[0]);
i = PyInt_FromString(&cprd[0], NULL, 10);
//printf("\nget_period() returning %i.\n", PyInt_AsLong(i));
Py_INCREF(i);
return i;
}
static PyObject *
PWM_get_polarity(PWM * self) {
char cpol[2];
PyObject * i;
getl(self->fd_polarity, &cpol[0]);
i = PyInt_FromString(&cpol[0], NULL, 10);
//printf("get_polarity() returning %i.\n", PyInt_AsLong(i));
Py_INCREF(i);
return i;
}
static PyObject *
_doc2pyobj(rapidjson::Document& doc, char *text)
{
int is_float;
unsigned int offset;
PyObject *pyjson;
if (!(doc.IsArray() || doc.IsObject())) {
switch (text[0]) {
case 't':
return PyBool_FromLong(1);
case 'f':
return PyBool_FromLong(0);
case 'n':
Py_RETURN_NONE;
case '"':
#ifdef PY3
return PyString_FromStringAndSize(text + 1, strlen(text) - 2);
#else
PyObject *utf8item;
utf8item = PyUnicode_FromStringAndSize(text + 1, strlen(text) - 2);
if (utf8item) {
return utf8item;
} else {
return PyString_FromStringAndSize(text + 1, strlen(text) - 2);
}
#endif
default:
is_float = 0;
for (offset = 0; offset < strlen(text); offset++) {
switch (text[offset]) {
case '.':
case 'e':
case 'E':
is_float = 1;
break;
}
if (is_float) break;
}
if (is_float) {
pyjson = PyFloat_FromDouble(atof(text));
}
else {
pyjson = PyInt_FromString(text, NULL, 10);
}
return pyjson;
}
}
return doc2pyobj(doc);
}
static PyObject *
pyrapidjson_loads(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = {(char *)"text", NULL};
char *text;
PyObject *pyjson;
rapidjson::Document doc;
int is_float;
unsigned int offset;
/* Parse arguments */
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", kwlist, &text))
return NULL;
doc.Parse(text);
if (!(doc.IsArray() || doc.IsObject())) {
switch (text[0]) {
case 't':
return PyBool_FromLong(1);
case 'f':
return PyBool_FromLong(0);
case 'n':
Py_RETURN_NONE;
case '"':
return PyString_FromStringAndSize(text + 1, strlen(text) - 2);
default:
is_float = 0;
for (offset = 0; offset < strlen(text); offset++) {
switch (text[offset]) {
case '.':
case 'e':
case 'E':
is_float = 1;
break;
}
if (is_float) break;
}
if (is_float) {
pyjson = PyFloat_FromDouble(atof(text));
}
else {
pyjson = PyInt_FromString(text, NULL, 10);
}
return pyjson;
}
}
return doc2pyobj(doc);
}
PyObject *
PyInt_FromUnicode(Py_UNICODE *s, int length, int base)
{
char buffer[256];
if (length >= sizeof(buffer)) {
PyErr_SetString(PyExc_ValueError,
"int() literal too large to convert");
return NULL;
}
if (PyUnicode_EncodeDecimal(s, length, buffer, NULL))
return NULL;
return PyInt_FromString(buffer, NULL, base);
}
PyObject* PyInt_FromUnicode(Py_UNICODE* s, Py_ssize_t length, int base) noexcept {
PyObject* result;
char* buffer = (char*)PyMem_MALLOC(length + 1);
if (buffer == NULL)
return PyErr_NoMemory();
if (PyUnicode_EncodeDecimal(s, length, buffer, NULL)) {
PyMem_FREE(buffer);
return NULL;
}
result = PyInt_FromString(buffer, NULL, base);
PyMem_FREE(buffer);
return result;
}
/* Add a check for embedded NULL-bytes in the argument. */
static PyObject *
int_from_string(const char *s, int len)
{
char *end;
PyObject *x;
x = PyInt_FromString((char*)s, &end, 10);
if (x == NULL)
return NULL;
if (end != s + len) {
PyErr_SetString(PyExc_ValueError,
"null byte in argument for int()");
Py_DECREF(x);
return NULL;
}
return x;
}
/* -interp, +buf */
static inline PyObject *CReader_readNum(CReader_Buffer *buffer)
{
PyObject *res;
off_t pos = 0;
char isf = 0;
char isl = 0;
char c;
while (1)
{
if (!buffer->type->extend(buffer, pos + 1))
break;
c = buffer->buf[buffer->pos + pos];
switch (c)
{
case SEPARATORS:
case WHITESPACE:
goto CReader_readNum_end;
case 'F': case 'f': case 'E': case 'e': case '.':
isf = 1;
break;
case 'L': case 'l':
isl = 1;
break;
}
pos++;
}
CReader_readNum_end:
{
char numstr[pos + 1];
buffer->type->cut(buffer, numstr, pos); /* Nah, we've allready done extend on this, so this *can't* fail */
numstr[pos] = '\0';
CReader_Buffer_lockInterpreter(buffer);
if (isf)
res = PyFloat_FromDouble(atof(numstr));
else if (isl)
res = PyLong_FromString(numstr, NULL, 0);
else
res = PyInt_FromString(numstr, NULL, 0);
CReader_Buffer_releaseInterpreter(buffer);
return res;
}
}
static int handle_number(void *ctx, const char *value, unsigned int length)
{
_YajlDecoder *self = (_YajlDecoder *)(ctx);
PyObject *object;
#ifdef IS_PYTHON3
PyBytesObject *string;
#else
PyObject *string;
#endif
int floaty_char;
// take a moment here to scan the input string to see if there's
// any chars which suggest this is a floating point number
for (floaty_char = 0; floaty_char < length; floaty_char++) {
switch (value[floaty_char]) {
case '.': case 'e': case 'E': goto floatin;
}
}
floatin:
#ifdef IS_PYTHON3
string = (PyBytesObject *)PyBytes_FromStringAndSize(value, length);
if (floaty_char >= length) {
object = PyLong_FromString(string->ob_sval, NULL, 10);
} else {
object = PyFloat_FromString((PyObject *)string);
}
#else
string = PyString_FromStringAndSize(value, length);
if (floaty_char >= length) {
object = PyInt_FromString(PyString_AS_STRING(string), NULL, 10);
} else {
object = PyFloat_FromString(string, NULL);
}
#endif
Py_XDECREF(string);
return PlaceObject(self, object);
}
static PyObject*
decode_number(JSONData *jsondata)
{
PyObject *object, *str;
int is_float;
char *ptr;
// validate number and check if it's floating point or not
ptr = jsondata->ptr;
is_float = False;
if (*ptr == '-' || *ptr == '+')
ptr++;
if (*ptr == '0') {
ptr++;
if (isdigit(*ptr))
goto number_error;
} else if (isdigit(*ptr))
skipDigits(ptr);
else
goto number_error;
if (*ptr == '.') {
is_float = True;
ptr++;
if (!isdigit(*ptr))
goto number_error;
skipDigits(ptr);
}
if (*ptr == 'e' || *ptr == 'E') {
is_float = True;
ptr++;
if (*ptr == '+' || *ptr == '-')
ptr++;
if (!isdigit(*ptr))
goto number_error;
skipDigits(ptr);
}
str = PyString_FromStringAndSize(jsondata->ptr, ptr - jsondata->ptr);
if (str == NULL)
return NULL;
if (is_float)
object = PyFloat_FromString(str, NULL);
else
object = PyInt_FromString(PyString_AS_STRING(str), NULL, 10);
Py_DECREF(str);
if (object == NULL)
goto number_error;
jsondata->ptr = ptr;
return object;
number_error:
PyErr_Format(JSON_DecodeError, "invalid number starting at position "
SSIZE_T_F, (Py_ssize_t)(jsondata->ptr - jsondata->str));
return NULL;
}
static PyObject*
decode_number(JSONData *jsondata)
{
PyObject *object, *str;
int c, is_float, should_stop;
char *ptr;
// check if we got a floating point number
ptr = jsondata->ptr;
is_float = should_stop = False;
while (True) {
c = *ptr;
if (c == 0)
break;
switch(c) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '-':
case '+':
break;
case '.':
case 'e':
case 'E':
is_float = True;
break;
default:
should_stop = True;
}
if (should_stop) {
break;
}
ptr++;
}
str = PyString_FromStringAndSize(jsondata->ptr, ptr - jsondata->ptr);
if (str == NULL)
return NULL;
if (is_float) {
object = PyFloat_FromString(str, NULL);
} else {
object = PyInt_FromString(PyString_AS_STRING(str), NULL, 10);
}
Py_DECREF(str);
if (object == NULL) {
PyErr_Format(JSON_DecodeError, "invalid number starting at position "
SSIZE_T_F, (Py_ssize_t)(jsondata->ptr - jsondata->str));
} else {
jsondata->ptr = ptr;
}
return object;
}
NUITKA_MAY_BE_UNUSED static PyObject *TO_INT2( PyObject *value, PyObject *base )
{
// TODO: Need to check if 3.4 is really the first version to do this.
#if PYTHON_VERSION < 340
long base_int = PyInt_AsLong( base );
#else
Py_ssize_t base_int = PyNumber_AsSsize_t( base, NULL );
#endif
if (unlikely( base_int == -1 ))
{
PyObject *error = GET_ERROR_OCCURRED();
if (likely( error ))
{
#if PYTHON_VERSION >= 300
if ( EXCEPTION_MATCH_BOOL_SINGLE( error, PyExc_OverflowError ) )
{
PyErr_Format(
PyExc_ValueError,
#if PYTHON_VERSION < 324
"int() arg 2 must be >= 2 and <= 36"
#else
"int() base must be >= 2 and <= 36"
#endif
);
}
#endif
return NULL;
}
}
#if PYTHON_VERSION >= 300
if (unlikely( ( base_int != 0 && base_int < 2 ) || base_int > 36 ))
{
PyErr_Format(
PyExc_ValueError,
#if PYTHON_VERSION < 324
"int() arg 2 must be >= 2 and <= 36"
#else
"int() base must be >= 2 and <= 36"
#endif
);
return NULL;
}
#endif
#if PYTHON_VERSION < 300
if (unlikely( !Nuitka_String_Check( value ) && !PyUnicode_Check( value ) ))
{
PyErr_Format(
PyExc_TypeError,
"int() can't convert non-string with explicit base"
);
return NULL;
}
char *value_str = Nuitka_String_AsString( value );
if (unlikely( value_str == NULL ))
{
return NULL;
}
PyObject *result = PyInt_FromString( value_str, NULL, base_int );
if (unlikely( result == NULL ))
{
return NULL;
}
return result;
#else
if ( PyUnicode_Check( value ) )
{
#if PYTHON_VERSION < 330
char *value_str = Nuitka_String_AsString( value );
if (unlikely( value_str == NULL ))
{
return NULL;
}
PyObject *result = PyInt_FromString( value_str, NULL, base_int );
if (unlikely( result == NULL ))
{
return NULL;
}
return result;
#else
return PyLong_FromUnicodeObject( value, (int)base_int );
#endif
}
else if ( PyBytes_Check( value ) || PyByteArray_Check( value ) )
{
// Check for "NUL" as PyLong_FromString has no length parameter,
Py_ssize_t size = Py_SIZE( value );
char *value_str;
if ( PyByteArray_Check( value ) )
{
value_str = PyByteArray_AS_STRING( value );
}
else
{
value_str = PyBytes_AS_STRING( value );
}
PyObject *result = NULL;
if ( size != 0 && strlen( value_str ) == (size_t)size )
{
result = PyInt_FromString( value_str, NULL, (int)base_int );
}
if (unlikely( result == NULL ))
{
PyErr_Format(
PyExc_ValueError,
"invalid literal for int() with base %d: %R",
base_int,
value
);
return NULL;
}
return result;
}
else
{
PyErr_Format(
PyExc_TypeError,
"int() can't convert non-string with explicit base"
);
return NULL;
}
#endif
}
/**
* 将结果集的一项转变为相应类型的对象
**/
static PyObject*
wrap_to_Object(char* cell, int type, int len)
{
PyObject *res;
PyObject *v;
switch(type)
{
//文本或者字符串
case FIELD_TYPE_BLOB:
case FIELD_TYPE_LONG_BLOB:
case FIELD_TYPE_MEDIUM_BLOB:
case FIELD_TYPE_TINY_BLOB:
case FIELD_TYPE_STRING:
case FIELD_TYPE_VAR_STRING:
res = PyString_FromStringAndSize(cell, len);
break;
//整数对象
case FIELD_TYPE_ENUM:
case FIELD_TYPE_INT24:
case FIELD_TYPE_LONG:
case FIELD_TYPE_LONGLONG:
case FIELD_TYPE_SHORT:
case FIELD_TYPE_TINY:
res = PyInt_FromString(cell, NULL, 10);
break;
//浮点数
case FIELD_TYPE_DECIMAL:
case FIELD_TYPE_DOUBLE:
case FIELD_TYPE_FLOAT:
v = PyString_FromStringAndSize(cell, len);
res = PyFloat_FromString(v, NULL);
Py_XDECREF(v);
break;
//时间类型
case FIELD_TYPE_DATE:
case FIELD_TYPE_DATETIME:
case FIELD_TYPE_NEWDATE:
case FIELD_TYPE_TIME:
case FIELD_TYPE_TIMESTAMP:
res = PyString_FromStringAndSize(cell, len);
break;
//空值
case FIELD_TYPE_NULL:
res = Py_None;
Py_INCREF(res);
break;
//set类型
case FIELD_TYPE_SET:
res = Py_None;
Py_INCREF(res);
break;
case FIELD_TYPE_YEAR:
res = Py_None;
Py_INCREF(res);
break;
default:
Py_INCREF(Py_None);
return Py_None;
}
return res;
}
/**
******************************************************************************************************
* Iterates over the hosts in the cluster and creates the list to be returned to the python client.
*
* @param err as_error object
* @param command Request string sent from the python client
* @param nodes_tuple List containing details of each host
* @param return_value List t o be returned back to the python client
* @param host_index Index of the list nodes_tuple
* @param index Index of the list to be returned.
*
* Returns information about a host.
********************************************************************************************************/
static PyObject * AerospikeClient_GetNodes_Returnlist(as_error* err,
PyObject * command, PyObject * nodes_tuple[], PyObject * return_value,
uint32_t host_index, Py_ssize_t index) {
char* tok = NULL;
char* saved = NULL;
PyObject * value_tok = NULL;
bool break_flag = false;
tok = strtok_r(PyString_AsString(command), INFO_REQUEST_RESPONSE_DELIMITER, &saved);
if (tok == NULL) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "Unable to get addr in service");
goto CLEANUP;
}
while (tok != NULL && (host_index < MAX_HOST_COUNT)) {
tok = strtok_r(NULL, IP_PORT_DELIMITER, &saved);
if (tok == NULL) {
goto CLEANUP;
}
nodes_tuple[host_index] = PyTuple_New(2);
value_tok = PyString_FromString(tok);
PyTuple_SetItem(nodes_tuple[host_index], 0 , value_tok);
//Py_DECREF(value_tok);
if(strcmp(PyString_AsString(command),"response_services_p")) {
tok = strtok_r(NULL, HOST_DELIMITER, &saved);
if (tok == NULL) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "Unable to get port");
goto CLEANUP;
}
if (strstr(tok, INFO_RESPONSE_END)) {
tok = strtok_r(tok, INFO_RESPONSE_END, &saved);
break_flag = true;
}
} else {
tok = strtok_r(NULL, INFO_RESPONSE_END, &saved);
if (tok == NULL) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "Unable to get port in service");
goto CLEANUP;
}
}
value_tok = PyInt_FromString(tok, NULL, 10);
PyTuple_SetItem(nodes_tuple[host_index], 1 , value_tok);
PyList_Insert(return_value, index , nodes_tuple[host_index]);
Py_DECREF(nodes_tuple[host_index]);
index++;
host_index++;
if (break_flag == true) {
goto CLEANUP;
}
}
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;
}
return return_value;
}
/**
******************************************************************************************************
* Iterates over the hosts in the cluster and creates the list to be returned to the python client.
*
* @param err as_error object
* @param command Request string sent from the python client
* @param nodes_tuple List containing details of each host
* @param return_value List t o be returned back to the python client
* @param host_index Index of the list nodes_tuple
* @param index Index of the list to be returned.
*
* Returns information about a host.
********************************************************************************************************/
static PyObject * AerospikeClient_GetNodes_Returnlist(as_error* err,
PyObject * command, PyObject * nodes_tuple[], PyObject * return_value,
uint32_t host_index, Py_ssize_t index) {
char* tok = NULL;
char* saved = NULL;
PyObject * value_tok = NULL;
bool break_flag = false;
tok = strtok_r(PyStr_AsString(command), INFO_REQUEST_RESPONSE_DELIMITER, &saved);
if (tok == NULL) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "Unable to get addr in service");
goto CLEANUP;
}
while (tok != NULL && (host_index < MAX_HOST_COUNT)) {
tok = strtok_r(NULL, IP_PORT_DELIMITER, &saved);
#if defined(__APPLE__)
if (tok == NULL || saved == NULL) {
#else
if (tok == NULL || *saved == '\0') {
#endif
goto CLEANUP;
}
nodes_tuple[host_index] = PyTuple_New(2);
value_tok = PyStr_FromString(tok);
PyTuple_SetItem(nodes_tuple[host_index], 0 , value_tok);
//Py_DECREF(value_tok);
if(strcmp(PyStr_AsString(command),"response_services_p")) {
tok = strtok_r(NULL, HOST_DELIMITER, &saved);
if (tok == NULL) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "Unable to get port");
goto CLEANUP;
}
if (strstr(tok, INFO_RESPONSE_END)) {
tok = strtok_r(tok, INFO_RESPONSE_END, &saved);
break_flag = true;
}
} else {
tok = strtok_r(NULL, INFO_RESPONSE_END, &saved);
if (tok == NULL) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "Unable to get port in service");
goto CLEANUP;
}
}
value_tok = PyInt_FromString(tok, NULL, 10);
PyTuple_SetItem(nodes_tuple[host_index], 1 , value_tok);
PyList_Insert(return_value, index , nodes_tuple[host_index]);
Py_DECREF(nodes_tuple[host_index]);
index++;
host_index++;
if (break_flag == true) {
goto CLEANUP;
}
}
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;
}
return return_value;
}
/**
******************************************************************************************************
* Returns data about the nodes to AerospikeClient_GetNodes.
*
* @param self AerospikeClient object
*
* Returns a list containing the details of the nodes.
********************************************************************************************************/
static PyObject * AerospikeClient_GetNodes_Invoke(
AerospikeClient * self) {
PyObject * response_services_p = NULL;
PyObject * response_service_p = NULL;
PyObject * nodes_tuple[MAX_HOST_COUNT] = {0};
PyObject * return_value = PyList_New(0);
as_error err;
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;
}
PyObject * py_req_str = NULL;
py_req_str = PyStr_FromString("services");
response_services_p = AerospikeClient_InfoNode_Invoke(self, py_req_str, NULL, NULL);
Py_DECREF(py_req_str);
if(!response_services_p) {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Services call returned an error");
goto CLEANUP;
}
py_req_str = PyStr_FromString("service");
response_service_p = AerospikeClient_InfoNode_Invoke(self, py_req_str, NULL, NULL);
Py_DECREF(py_req_str);
if(!response_service_p) {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "Service call returned an error");
goto CLEANUP;
}
return_value = AerospikeClient_GetNodes_Returnlist(&err, response_service_p, nodes_tuple, return_value, 0, 0);
if( return_value )
return_value = AerospikeClient_GetNodes_Returnlist(&err, response_services_p, nodes_tuple, return_value, 1, 1);
CLEANUP:
if(response_services_p) {
Py_DECREF(response_services_p);
}
if(response_service_p) {
Py_DECREF(response_service_p);
}
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;
}
return return_value;
}
/* Assign to the i-th element of self */
static Py_ssize_t DataBuf_ass_item(PyObject *_self, Py_ssize_t i, PyObject *v)
{
DataBufObj *self = (DataBufObj *)_self;
void *item;
PyObject *obj = NULL;
PyObject *obj2 = NULL;
Py_ssize_t size;
if (v == NULL) {
PyErr_SetString(PyExc_TypeError, "buffer delete not supported");
return -1;
}
if (i < 0 || i >= self->fmt.count) {
PyErr_SetString(PyExc_IndexError, "buffer index out of range");
return -1;
}
if (v == Py_None) {
self->indicator[i] = CS_NULLDATA;
return 0;
}
item = self->buff + self->fmt.maxlength * i;
switch (self->fmt.datatype) {
case CS_LONGCHAR_TYPE:
case CS_VARCHAR_TYPE:
case CS_TEXT_TYPE:
case CS_IMAGE_TYPE:
case CS_LONGBINARY_TYPE:
case CS_VARBINARY_TYPE:
case CS_BINARY_TYPE:
size = PyString_Size(v);
if (size > self->fmt.maxlength) {
PyErr_SetString(PyExc_TypeError, "string too long for buffer");
return -1;
}
memmove(item, PyString_AsString(v), size);
if (size < self->fmt.maxlength)
((char*)item)[size] = '\0';
self->copied[i] = size;
break;
case CS_CHAR_TYPE:
if (!PyString_Check(v)) {
obj = PyObject_Str(v);
if (obj == NULL)
return -1;
v = obj;
}
size = PyString_Size(v);
if (size > self->fmt.maxlength) {
PyErr_SetString(PyExc_TypeError, "string too long for buffer");
Py_XDECREF(obj);
return -1;
}
memmove(item, PyString_AsString(v), size);
if (size < self->fmt.maxlength)
((char*)item)[size] = '\0';
self->copied[i] = size;
break;
case CS_BIT_TYPE:
if (!PyInt_Check(v)) {
PyErr_SetString(PyExc_TypeError, "integer expected");
return -1;
}
*(CS_BIT*)item = (CS_BIT)PyInt_AsLong(v);
self->copied[i] = self->fmt.maxlength;
break;
case CS_TINYINT_TYPE:
if (!PyInt_Check(v)) {
PyErr_SetString(PyExc_TypeError, "integer expected");
return -1;
}
*(CS_TINYINT*)item = (CS_TINYINT)PyInt_AsLong(v);
self->copied[i] = self->fmt.maxlength;
break;
case CS_SMALLINT_TYPE:
if (!PyInt_Check(v)) {
PyErr_SetString(PyExc_TypeError, "integer expected");
return -1;
}
*(CS_SMALLINT*)item = (CS_SMALLINT)PyInt_AsLong(v);
self->copied[i] = self->fmt.maxlength;
break;
case CS_INT_TYPE:
if (PyString_Check(v)) {
obj = PyInt_FromString(PyString_AsString(v), NULL, 0);
if (obj == NULL) {
return -1;
}
v = obj;
}
if (!PyInt_Check(v)) {
PyErr_SetString(PyExc_TypeError, "integer expected");
Py_XDECREF(obj);
return -1;
}
*(CS_INT*)item = PyInt_AsLong(v);
self->copied[i] = self->fmt.maxlength;
break;
case CS_LONG_TYPE:
if (!PyLong_Check(v)) {
PyErr_SetString(PyExc_TypeError, "long expected");
return -1;
}
*(CS_LONG*)item = PyLong_AsLong(v);
if (PyErr_Occurred()) {
return -1;
}
self->copied[i] = self->fmt.maxlength;
break;
case CS_MONEY_TYPE:
if (!money_from_value((MoneyUnion*)item, CS_MONEY_TYPE, v))
return -1;
self->copied[i] = self->fmt.maxlength;
break;
case CS_MONEY4_TYPE:
if (!money_from_value((MoneyUnion*)item, CS_MONEY4_TYPE, v))
return -1;
self->copied[i] = self->fmt.maxlength;
break;
case CS_FLOAT_TYPE:
if (!PyFloat_Check(v)) {
PyErr_SetString(PyExc_TypeError, "float expected");
return -1;
}
*(CS_FLOAT*)item = PyFloat_AsDouble(v);
self->copied[i] = self->fmt.maxlength;
break;
case CS_REAL_TYPE:
if (!PyFloat_Check(v)) {
PyErr_SetString(PyExc_TypeError, "float expected");
return -1;
}
*(CS_REAL*)item = (CS_REAL)PyFloat_AsDouble(v);
self->copied[i] = self->fmt.maxlength;
break;
case CS_DATETIME_TYPE:
if (pydatetime_check(v)) {
obj = DateTime_FromPyDateTime(v);
if (obj == NULL)
return -1;
v = obj;
} else if (PyString_Check(v)) {
obj2 = PyObject_Str(v);
if (obj2 == NULL) {
return -1;
}
obj = DateTime_FromString(obj2);
Py_XDECREF(obj2);
if (obj == NULL) {
return -1;
}
v = obj;
}
if (!DateTime_Check(v)) {
PyErr_SetString(PyExc_TypeError, "datetime expected");
Py_XDECREF(obj);
return -1;
}
if (datetime_assign(v, CS_DATETIME_TYPE, item) != CS_SUCCEED)
return -1;
self->copied[i] = self->fmt.maxlength;
break;
case CS_DATETIME4_TYPE:
if (!DateTime_Check(v)) {
PyErr_SetString(PyExc_TypeError, "datetime expected");
return -1;
}
if (datetime_assign(v, CS_DATETIME4_TYPE, item) != CS_SUCCEED)
return -1;
self->copied[i] = self->fmt.maxlength;
break;
#ifdef CS_DATE_TYPE
case CS_DATE_TYPE:
if (pydate_check(v)) {
obj = Date_FromPyDate(v);
if (obj == NULL)
return -1;
v = obj;
} else if (PyString_Check(v)) {
obj2 = PyObject_Str(v);
if (obj2 == NULL) {
return -1;
}
obj = Date_FromString(obj2);
Py_XDECREF(obj2);
if (obj == NULL) {
return -1;
}
v = obj;
}
if (!Date_Check(v)) {
PyErr_SetString(PyExc_TypeError, "date expected");
Py_XDECREF(obj);
return -1;
}
if (date_assign(v, CS_DATE_TYPE, item) != CS_SUCCEED)
return -1;
self->copied[i] = self->fmt.maxlength;
break;
#endif /* CS_DATE_TYPE */
case CS_DECIMAL_TYPE:
case CS_NUMERIC_TYPE:
if (!numeric_from_value((CS_NUMERIC*)item, -1, -1, v))
return -1;
self->copied[i] = self->fmt.maxlength;
break;
default:
PyErr_SetString(PyExc_TypeError, "unknown data format");
return -1;
}
Py_XDECREF(obj);
self->indicator[i] = 0;
return 0;
}
