static int ws_onclose(libwebsock_client_state *state) { //generate python client state object and call python callable PyObject *stateObject = NULL; PyObject *arglist; PyObject **clients_array; Py_ssize_t clients_len; int clients_idx; clients_len = PySequence_Size(connected_clients_list); clients_array = PySequence_Fast_ITEMS(connected_clients_list); for(clients_idx = 0; clients_idx < clients_len; clients_array++, clients_idx++) { if(*clients_array && ((libwebsock_ClientStateObject *)*clients_array)->state == state) { stateObject = *clients_array; break; } } if(stateObject) { PySequence_DelItem(connected_clients_list, PySequence_Index(connected_clients_list, stateObject)); if(onclose_callback) { arglist = Py_BuildValue("(O)", stateObject); PyObject_CallObject(onclose_callback, arglist); Py_DECREF(arglist); } Py_DECREF(stateObject); } return 0; }
/* {{{ _syspath_append */ static int _syspath_append(const char *dir) { PyObject *sys, *path, *dirstr; if (dir == NULL) { return -1; } sys = PyImport_ImportModule("sys"); path = PyObject_GetAttrString(sys, "path"); dirstr = PyString_FromString(dir); /* Append dir to sys.path if it's not already there. */ if (PySequence_Index(path, dirstr) == -1) { PyErr_Clear(); PyList_Append(path, dirstr); } Py_DECREF(dirstr); Py_DECREF(path); Py_DECREF(sys); return 0; }
// dtor static void AtTime_dealloc( PyObject* self ) { AtTime * at = (AtTime*)self; PyObject * tsd = PyThreadState_GetDict(); PyObject * atd = PyDict_GetItemString(tsd, "_AtTime" ); if( atd ) { PyObject * cur_stack = PyDict_GetItemString( atd, "current_stack" ); PyObject * time_stack = PyDict_GetItemString( atd, "time_stack" ); Py_ssize_t time_top = PyList_Size(time_stack) - 1; PyObject * hashKey = PyLong_FromLong( PyObject_Hash((PyObject*)self) ); Py_ssize_t pos = PySequence_Index(cur_stack, hashKey); Py_DECREF(hashKey); // Restore the correct time value if we are current if( PyList_Size(cur_stack) == pos + 1 ) { thread_local(current_time) = PyLong_AsLong( PyList_GetItem( time_stack, time_top ) ); //PySys_WriteStdout( "Current AtTime object destroyed, restoring thread_local(current_time) to %i\n", thread_local(current_time) ); PySequence_DelItem(time_stack,time_top); } else // If we aren't current, then we delete the time at the position one above where we are in the current_stack PySequence_DelItem(time_stack,pos+1); PySequence_DelItem(cur_stack,pos); // If we are the last AtTime object local to this thread, then remove the _AtTime thread-local dict if( PyList_Size(cur_stack) == 0 ) { thread_local(use_time_context) = (PyDict_GetItemString( atd, "restore_use_time_context" ) == Py_True) ? TRUE : FALSE; //PySys_WriteStdout( "Last AtTime object destroyed, setting thread_local(use_time_context) to FALSE\n" ); PyDict_DelItemString(tsd, "_AtTime"); } } self->ob_type->tp_free(self); }
/** * 关闭连接 * args[0] 连接对象 * args[1] 连接池对象 **/ static PyObject* connect_close(PyObject *self, PyObject *args) { PyConnectPoolObject *pool = (PyConnectPoolObject*)PySequence_GetItem(args, 1); PyConnectObject *con = (PyConnectObject*)PySequence_GetItem(args, 0); int index; if(!pool || !con || !PyConnectPool_CheckExact(pool) || !PyConnect_CheckExact(con)) { PyErr_SetString(PyExc_RuntimeError, "参数错误"); return NULL; } //从busy连接队列中删除掉 index = PySequence_Index(pool->cons_busy, (PyObject*)con); if(index != -1) PySequence_DelItem(pool->cons_busy, index); //检查空闲的连接池数量 //如果空闲的连接过多,则关闭多余的连接 if(PySequence_Length(pool->cons_free) > pool->free_max) { connect_dealloc(con); } else { PyList_Insert((PyObject*)(pool->cons_free), 0, (PyObject*)con); } return Py_True; }
/** tuple index. * @return index if found * @throw index_err if not found * @throw type_err */ long index(const obj& o)const { long r = PySequence_Index(_p, o.p()); if(r == -1) throw index_err("index failed"); return r; }
PyObject *Timer_end(Timer *self, PyObject *args) { if (!(self->flags & TIMER_ACTIVE)) Py_RETURN_NONE; if (PySequence_DelItem(ACTIVE_TIMERS, PySequence_Index(ACTIVE_TIMERS, (PyObject *)self)) == -1) return NULL; self->flags &= ~TIMER_ACTIVE; POST_EVENT(self, TIMER_END); Py_RETURN_NONE; }
static PyObject *t_sequence_index(t_sequence *self, PyObject *value) { int index; if (self->itemvalue.flags & V_PURE) index = PySequence_Index(self->sequence, value); else { value = _useValue(self, value); if (!value) return NULL; index = PySequence_Index(self->sequence, value); Py_DECREF(value); } if (index < 0) return NULL; return PyInt_FromLong(index); }
static PyObject * evregpy_disconnect (PyObject *self, PyObject *function) { PyObject *func; int index; PyObject *callback_list = (((eventregistry_object *) self)->callbacks); if (!PyArg_ParseTuple (function, "O", &func)) return NULL; index = PySequence_Index (callback_list, func); if (index < 0) Py_RETURN_NONE; if (PySequence_DelItem (callback_list, index) < 0) return NULL; Py_RETURN_NONE; }
int List::index(const Object &obj) const { return PySequence_Index(mPtr, obj.borrowReference()); }
/* Set item to LDAPEntry with a case-insensitive key. */ int LDAPEntry_SetItem(LDAPEntry *self, PyObject *key, PyObject *value) { int found = 0; int rc = 0; int status = 1; char *newkey = lowercase(PyObject2char(key)); LDAPValueList *list; /* Search for a match. */ key = searchLowerCaseKeyMatch(self, key, &found); if (found == 1) { status = 2; } if (value != NULL) { /* If theres an item with a `dn` key, and with a string value set to the dn attribute. */ if (strcmp(newkey, "dn") == 0) { if (PyUnicode_Check(value)) { char *dnstr = PyObject2char(value); LDAPEntry_SetStringDN(self, dnstr); free(dnstr); } else { PyErr_SetString(PyExc_TypeError, "Distinguished name must be string type."); Py_DECREF(key); return -1; } } else { /* Set the new value to the item. */ if (LDAPValueList_Check(value) == 0) { /* Convert value to LDAPValueList object. */ list = LDAPValueList_New(); if (PyList_Check(value) || PyTuple_Check(value)) { LDAPValueList_Extend(list, value); } else { LDAPValueList_Append(list, value); } rc = PyDict_SetItem((PyObject *)self, key, (PyObject *)list); list->status = status; Py_DECREF(list); } else { rc = PyDict_SetItem((PyObject *)self, key, value); ((LDAPValueList *)value)->status = status; } /* Avoid inconsistency. (same key in the added and the deleted list) */ if (PySequence_Contains((PyObject *)self->deleted, key)) { if (UniqueList_Remove(self->deleted, key) != 0) return -1; } if (rc != 0) return rc; /* New key should be added to the attribute list. */ if (found == 0) { if (UniqueList_Append(self->attributes, key) != 0) { Py_DECREF(key); return -1; } } } } else { /* This means, it has to remove the item. */ if (PyDict_DelItem((PyObject *)self, key) != 0) return -1; if (UniqueList_Append(self->deleted, key) != 0) return -1; /* Remove from the attributes list. */ if (PySequence_DelItem((PyObject *)self->attributes, PySequence_Index((PyObject *)self->attributes, key)) != 0) { Py_DECREF(key); return -1; } } Py_DECREF(key); return 0; }
/** tuple find a item. * @return index if found, -1 otherwise * @throw type_err */ long find(const obj& o)const { long r = PySequence_Index(_p, o.p()); return r; }