static int PongoDict_SetItem(PongoDict *self, PyObject *key, PyObject *value) { dbtype_t k; dbtype_t v; int ret = -1; dblock(self->ctx); k = from_python(self->ctx, key); if (!PyErr_Occurred()) { if (value == NULL) { if (dbobject_delitem(SELF_CTX_AND_DBPTR, k, &v, self->ctx->sync) == 0) { ret = 0; } else { PyErr_SetObject(PyExc_KeyError, key); } } else { v = from_python(self->ctx, value); if (!PyErr_Occurred() && dbobject_setitem(SELF_CTX_AND_DBPTR, k, v, self->ctx->sync) == 0) ret = 0; } } dbunlock(self->ctx); return ret; }
static PyObject * PongoIter_expr(PyObject *ob, PyObject *args, PyObject *kwargs) { PongoIter *self = (PongoIter*)ob; PyObject *lhs = Py_None, *rhs = Py_None; int lhex = 0, rhex = 0; char *kwlist[] = {"lhs", "rhs", "lhex", "rhex", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOii:expr", kwlist, &lhs, &rhs, &lhex, &rhex)) return NULL; dblock(self->ctx); // Force lhex to be 0 or 1, and rhex to be 0 or -1 self->lhex = !!lhex; self->rhex = -(!!rhex); // Convert the lhs and rhs to pongo objects and reference them in the pidcache self->lhdata = from_python(self->ctx, lhs); if (self->lhdata.all) pidcache_put(self->ctx, &self->lhdata, self->lhdata); self->rhdata = from_python(self->ctx, rhs); if (self->rhdata.all) pidcache_put(self->ctx, &self->rhdata, self->rhdata); dbunlock(self->ctx); Py_INCREF(self); return (PyObject*)self; }
static PyObject * PongoDict_search(PongoDict *self, PyObject *args) { PyObject *path, *value, *ret=NULL; dbtype_t dbpath, dbvalue, dbrslt; char *rel; char *sep = "."; int decpath = 0; relop_t relop; if (!PyArg_ParseTuple(args, "OsO:search", &path, &rel, &value)) return NULL; if (!strcmp(rel, "==") || !strcmp(rel, "eq")) { relop = db_EQ; } else if (!strcmp(rel, "!=") || !strcmp(rel, "ne")) { relop = db_NE; } else if (!strcmp(rel, "<") || !strcmp(rel, "lt")) { relop = db_LT; } else if (!strcmp(rel, "<=") || !strcmp(rel, "le")) { relop = db_LE; } else if (!strcmp(rel, ">") || !strcmp(rel, "gt")) { relop = db_GT; } else if (!strcmp(rel, ">=") || !strcmp(rel, "ge")) { relop = db_GE; } else { PyErr_Format(PyExc_ValueError, "Unknown relop '%s'", rel); return NULL; } if (PyString_Check(path)) { path = PyObject_CallMethod(path, "split", "s", sep); decpath = 1; } if (!PySequence_Check(path)) { PyErr_Format(PyExc_TypeError, "path must be a sequence"); return NULL; } dblock(self->ctx); dbpath = from_python(self->ctx, path); if (decpath) Py_DECREF(path); if (dbtype(self->ctx, dbpath) == List) { dbvalue = from_python(self->ctx, value); if (!PyErr_Occurred()) { dbrslt = dbcollection_new(self->ctx, 0); db_search(SELF_CTX_AND_DBPTR, dbpath, -1, relop, dbvalue, dbrslt); // PROXYCHLD means turn the root object into a real dict, but // create proxy objects for all children. ret = to_python(self->ctx, dbrslt, TP_PROXYCHLD); } } else { PyErr_Format(PyExc_Exception, "path type isn't List (%d)", dbtype(self->ctx, dbpath)); } dbunlock(self->ctx); return ret; }
PyObject* do_call(PyObject* args, PyObject* keywords) const { ref dict(keywords ? ref(keywords, ref::increment_count) : ref(PyDict_New())); return to_python( (*m_pf)(from_python(args, boost::python::type<Args>()), from_python(dict.get(), boost::python::type<Keywords>()))); }
static PyObject * PongoDict_set(PongoDict *self, PyObject *args, PyObject *kwargs) { PyObject *key, *value; PyObject *klist = NULL; PyObject *ret = NULL; dbtype_t k, v; int sync = self->ctx->sync; int fail = 0; multi_t op = multi_SET; char *kwlist[] = {"key", "value", "sep", "sync", "fail", NULL}; char *sep = "."; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|sii:set", kwlist, &key, &value, &sep, &sync, &fail)) return NULL; k = DBNULL; dblock(self->ctx); if (PyString_Check(key) || PyUnicode_Check(key)) { klist = PyObject_CallMethod(key, "split", "s", sep); k = from_python(self->ctx, klist); Py_XDECREF(klist); } else { if (key == pongo_id) { sync |= PUT_ID; } else { k = from_python(self->ctx, key); } } v = from_python(self->ctx, value); if (!PyErr_Occurred()) { if (dbtype(self->ctx, k) == List) { if (fail) op = multi_SET_OR_FAIL; if (db_multi(SELF_CTX_AND_DBPTR, k, op, &v, sync) == 0) { ret = Py_None; } else { PyErr_SetObject(PyExc_KeyError, key); } } else if (db_multi(SELF_CTX_AND_DBPTR, k, op, &v, sync) == 0) { // db_mutli will tell us the newly created value of // "_id" when PUT_ID is enabled. ret = (sync & PUT_ID) ? to_python(self->ctx, v, TP_PROXY) : Py_None; } else { if (sync & PUT_ID) { PyErr_Format(PyExc_ValueError, "value must be a dictionary"); } else { PyErr_SetObject(PyExc_KeyError, key); } } } dbunlock(self->ctx); Py_XINCREF(ret); return ret; }
int _py_itermapping_cb(pgctx_t *ctx, int i, dbtype_t *key, dbtype_t *value, void *user) { PyObject *iter = (PyObject*)user; PyObject *item = PyIter_Next(iter); PyObject *k = PySequence_GetItem(item, 0); PyObject *v = PySequence_GetItem(item, 1); *key = from_python(ctx, k); *value = from_python(ctx, v); Py_DECREF(k); Py_DECREF(v); Py_DECREF(item); if (PyErr_Occurred()) return -1; return 0; }
PyObject* setter_function<ClassType, MemberType>::do_call( PyObject* args, PyObject* /* keywords */) const { PyObject* self; PyObject* value; if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &value)) return 0; typedef typename boost::call_traits<MemberType>::const_reference extract_type; from_python(self, type<ClassType*>())->*m_pm = from_python(value, type<extract_type>()); return none(); }
static PyObject * PongoDict_get(PongoDict *self, PyObject *args, PyObject *kwargs) { PyObject *key, *dflt = Py_None; PyObject *klist = NULL; PyObject *ret = NULL; dbtype_t k, v; char *sep = "."; char *kwlist[] = {"key", "default", "sep", NULL}; int r; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Os:get", kwlist, &key, &dflt, &sep)) return NULL; dblock(self->ctx); if (PyString_Check(key) || PyUnicode_Check(key)) { klist = PyObject_CallMethod(key, "split", "s", sep); k = from_python(self->ctx, klist); Py_XDECREF(klist); } else { k = from_python(self->ctx, key); } if (!PyErr_Occurred()) { if (dbtype(self->ctx, k) == List) { r = db_multi(SELF_CTX_AND_DBPTR, k, multi_GET, &v, 0); if (r == 0) { ret = to_python(self->ctx, v, TP_PROXY); } else if (dflt) { Py_INCREF(dflt); ret = dflt; } else { PyErr_SetObject(PyExc_KeyError, key); } } else if (dbobject_getitem(SELF_CTX_AND_DBPTR, k, &v) == 0) { ret = to_python(self->ctx, v, TP_PROXY); } else { if (dflt) { ret = dflt; Py_INCREF(ret); } else { PyErr_SetObject(PyExc_KeyError, key); } } } dbunlock(self->ctx); return ret; }
static PyObject * PongoDict_pop(PongoDict *self, PyObject *args, PyObject *kwargs) { PyObject *key, *dflt = NULL; PyObject *ret = NULL; dbtype_t k, v; int sync = self->ctx->sync; char *kwlist[] = {"key", "default", "sync", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Oi:pop", kwlist, &key, &dflt, &sync)) return NULL; dblock(self->ctx); k = from_python(self->ctx, key); if (!PyErr_Occurred()) { if (dbobject_delitem(SELF_CTX_AND_DBPTR, k, &v, sync) < 0) { if (dflt) { Py_INCREF(dflt); ret = dflt; } else { PyErr_SetObject(PyExc_KeyError, key); } } else { ret = to_python(self->ctx, v, TP_PROXY); } } dbunlock(self->ctx); return ret; }
int _py_sequence_cb(pgctx_t *ctx, int i, dbtype_t *item, void *user) { PyObject *seq = (PyObject*)user; PyObject *sqitem = PySequence_GetItem(seq, i); *item = from_python(ctx, sqitem); Py_DECREF(sqitem); if (PyErr_Occurred()) return -1; return 0; }
PyObject* getter_function<ClassType, MemberType>::do_call( PyObject* args, PyObject* /* keywords */) const { PyObject* self; if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self)) return 0; return to_python( from_python(self, type<const ClassType*>())->*m_pm); }
static PyObject * pongo_meta(PyObject *self, PyObject *args) { PongoCollection *data; pgctx_t *ctx; const char *key; PyObject *value = NULL, *ret = Py_None; if (!PyArg_ParseTuple(args, "Os|O:meta", &data, &key, &value)) return NULL; if (pongo_check(data)) return NULL; ctx = data->ctx; dblock(ctx); if (!strcmp(key, "chunksize")) { ret = PyLong_FromLongLong(ctx->root->meta.chunksize); if (value && value != Py_None) ctx->root->meta.chunksize = PyInt_AsLong(value); } else if (!strcmp(key, "id")) { ret = to_python(ctx, ctx->root->meta.id, 0); if (value) ctx->root->meta.id = from_python(ctx, value); } else if (!strcmp(key, ".sync")) { ret = PyInt_FromLong(ctx->sync); if (value && value != Py_None) ctx->sync = PyInt_AsLong(value); #ifdef WANT_UUID_TYPE } else if (!strcmp(key, ".uuid_class")) { ret = (PyObject*)uuid_class; if (value) uuid_class = (PyTypeObject*)value; } else if (!strcmp(key, ".uuid_constructor")) { ret = (PyObject*)uuid_constructor; if (value) uuid_constructor = value; #endif } else if (!strcmp(key, ".newkey")) { ret = pongo_newkey; if (value) { pongo_newkey = value; if (value == Py_None) { #ifdef WANT_UUID_TYPE ctx->newkey = _newkey; #else ctx->newkey = NULL; #endif } else { ctx->newkey = pongo_newkey_helper; } } } else { PyErr_Format(PyExc_Exception, "Unknown meta key %s", key); ret = NULL; } dbunlock(ctx); return ret; }
static dbtype_t pongo_newkey_helper(pgctx_t *ctx, dbtype_t value) { // FIXME: something wrong here. PyObject *ob; ob = PyObject_CallFunction(pongo_newkey, "(N)", to_python(ctx, value, 1)); if (ob) { value = from_python(ctx, ob); Py_DECREF(ob); } else { value = DBNULL; } return value; }
static int PongoDict_contains(PongoDict *self, PyObject *key) { dbtype_t k; int ret = 0; dblock(self->ctx); k = from_python(self->ctx, key); if (!PyErr_Occurred()) { ret = dbobject_contains(SELF_CTX_AND_DBPTR, k); } dbunlock(self->ctx); return ret; }
static PyObject * PongoDict_GetItem(PongoDict *self, PyObject *key) { dbtype_t k, v; PyObject *ret = NULL; dblock(self->ctx); k = from_python(self->ctx, key); if (!PyErr_Occurred()) { if (dbobject_getitem(SELF_CTX_AND_DBPTR, k, &v) == 0) { ret = to_python(self->ctx, v, TP_PROXY); } else { PyErr_SetObject(PyExc_KeyError, key); } } dbunlock(self->ctx); return ret; }
inline bool from_python(PyObject* p, boost::python::type<const bool&>) { return from_python(p, boost::python::type<bool>()); }
inline unsigned short from_python(PyObject* p, boost::python::type<const unsigned short&>) { return from_python(p, boost::python::type<unsigned short>()); }
inline short from_python(PyObject* p, boost::python::type<const short&>) { return from_python(p, boost::python::type<short>()); }
inline long from_python(PyObject* p, boost::python::type<const long&>) { return from_python(p, boost::python::type<long>()); }
inline int from_python(PyObject* p, boost::python::type<const int&>) { return from_python(p, boost::python::type<int>()); }
inline float from_python(PyObject* p, boost::python::type<const float&>) { return from_python(p, boost::python::type<float>()); }
inline double from_python(PyObject* p, boost::python::type<const double&>) { return from_python(p, boost::python::type<double>()); }
inline char from_python(PyObject* p, boost::python::type<const char&>) { return from_python(p, boost::python::type<char>()); }
inline unsigned long from_python(PyObject* p, boost::python::type<const unsigned long&>) { return from_python(p, boost::python::type<unsigned long>()); }
inline unsigned char from_python(PyObject* p, boost::python::type<const unsigned char&>) { return from_python(p, boost::python::type<unsigned char>()); }
inline std::string from_python(PyObject* p, boost::python::type<const std::string&>) { return from_python(p, boost::python::type<std::string>()); }
friend EnumType from_python(PyObject* x, boost::python::type<const EnumType&>) { return static_cast<EnumType>( from_python(x, boost::python::type<long>())); }
inline const char* from_python(PyObject* p, boost::python::type<const char* const&>) { return from_python(p, boost::python::type<const char*>()); }